/*
 * Copyright 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.prefabulated.bouncyball;

import android.content.Intent;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Trace;
import android.preference.ListPreference;
import android.preference.PreferenceManager;
import android.text.Layout;
import android.util.Log;
import android.view.Choreographer;
import android.view.Display;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.Surface;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.WindowManager;
import android.widget.GridLayout;
import android.widget.LinearLayout;
import android.widget.TextView;

import java.util.ArrayDeque;
import java.util.Locale;
import java.util.Queue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.AppCompatTextView;

public class OrbitActivity extends AppCompatActivity implements Choreographer.FrameCallback, SurfaceHolder.Callback {

    // Used to load the 'native-lib' library on application startup.
    static {
        System.loadLibrary("native-lib");
    }

    private static final long ONE_MS_IN_NS = 1000000;
    private static final long ONE_S_IN_NS = 1000 * ONE_MS_IN_NS;

    private static final String LOG_TAG = "OrbitActivity.java";

    private void configureGridCell(AppCompatTextView cell) {
        // A bunch of optimizations to reduce the cost of setText
        cell.setEllipsize(null);
        cell.setMaxLines(1);
        cell.setSingleLine(true);
        if (android.os.Build.VERSION.SDK_INT >= 23) {
            cell.setBreakStrategy(Layout.BREAK_STRATEGY_SIMPLE);
            cell.setHyphenationFrequency(Layout.HYPHENATION_FREQUENCY_NONE);
        }

        cell.setTextAppearance(getApplicationContext(), R.style.InfoTextSmall);
        cell.setText("0");
    }

    private void buildChoreographerInfoGrid() {
        GridLayout infoGrid = findViewById(R.id.choreographer_info_grid);

        // Add the header row
        GridLayout.Spec headerRowSpec = GridLayout.spec(0);
        for (int column = 0; column < mChoreographerInfoGrid[0].length; ++column) {
            AppCompatTextView cell = new AppCompatTextView(getApplicationContext());
            GridLayout.Spec colSpec = GridLayout.spec(column, 1.0f);
            cell.setLayoutParams(new GridLayout.LayoutParams(headerRowSpec, colSpec));
            configureGridCell(cell);

            if (column == 0) {
                cell.setText("");
            } else {
                cell.setText(String.format(Locale.US, "%d", column - 1));
            }
            infoGrid.addView(cell);
            mChoreographerInfoGrid[0][column] = cell;
        }

        // Add the data rows
        for (int row = 1; row < mChoreographerInfoGrid.length; ++row) {
            GridLayout.Spec rowSpec = GridLayout.spec(row);

            for (int column = 0; column < mChoreographerInfoGrid[row].length; ++column) {
                AppCompatTextView cell = new AppCompatTextView(getApplicationContext());
                GridLayout.Spec colSpec = GridLayout.spec(column, 1.0f);
                cell.setLayoutParams(new GridLayout.LayoutParams(rowSpec, colSpec));
                cell.setTextAppearance(getApplicationContext(), R.style.InfoTextSmall);
                configureGridCell(cell);

                if (column == 0) {
                    switch (row) {
                        case 1:
                            cell.setText(R.string.grid_1s_arr);
                            break;
                        case 2:
                            cell.setText(R.string.grid_1s_ts);
                            break;
                        case 3:
                            cell.setText(R.string.grid_1m_arr);
                            break;
                        case 4:
                            cell.setText(R.string.grid_1m_ts);
                            break;
                    }
                }
                infoGrid.addView(cell);
                mChoreographerInfoGrid[row][column] = cell;
            }
        }

        for (TextView[] row : mChoreographerInfoGrid) {
            for (TextView column : row) {
                column.setWidth(infoGrid.getWidth() / infoGrid.getColumnCount());
            }
        }
    }

    private void buildSwappyStatsGrid() {
        GridLayout infoGrid = findViewById(R.id.swappy_stats_grid);

        // Add the header row
        GridLayout.Spec headerRowSpec = GridLayout.spec(0);
        for (int column = 0; column < mSwappyGrid[0].length; ++column) {
            AppCompatTextView cell = new AppCompatTextView(getApplicationContext());
            GridLayout.Spec colSpec = GridLayout.spec(column, 1.0f);
            cell.setLayoutParams(new GridLayout.LayoutParams(headerRowSpec, colSpec));
            configureGridCell(cell);

            if (column == 0) {
                cell.setText("");
            } else {
                cell.setText(String.format(Locale.US, "%d", column - 1));
            }
            infoGrid.addView(cell);
            mSwappyGrid[0][column] = cell;
        }

        // Add the data rows
        for (int row = 1; row < mSwappyGrid.length; ++row) {
            GridLayout.Spec rowSpec = GridLayout.spec(row);

            for (int column = 0; column < mSwappyGrid[row].length; ++column) {
                AppCompatTextView cell = new AppCompatTextView(getApplicationContext());
                GridLayout.Spec colSpec = GridLayout.spec(column, 1.0f);
                cell.setLayoutParams(new GridLayout.LayoutParams(rowSpec, colSpec));
                cell.setTextAppearance(getApplicationContext(), R.style.InfoTextSmall);
                configureGridCell(cell);

                if (column == 0) {
                    switch (row) {
                        case 1:
                            cell.setText(R.string.idle_frames);
                            break;
                        case 2:
                            cell.setText(R.string.late_frames);
                            break;
                        case 3:
                            cell.setText(R.string.offset_frames);
                            break;
                        case 4:
                            cell.setText(R.string.latency_frames);
                            break;
                    }
                } else {
                    cell.setText("0%");
                }
                infoGrid.addView(cell);
                mSwappyGrid[row][column] = cell;
            }
        }

        for (TextView[] row : mSwappyGrid) {
            for (TextView column : row) {
                column.setWidth(infoGrid.getWidth() / infoGrid.getColumnCount());
            }
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_orbit);

        // Get display metrics

        WindowManager wm = getWindowManager();
        Display display = wm.getDefaultDisplay();
        float refreshRateHz = display.getRefreshRate();
        Log.i(LOG_TAG, String.format("Refresh rate: %.1f Hz", refreshRateHz));
        long refreshPeriodNanos = (long) (ONE_S_IN_NS / refreshRateHz);
        long appVsyncOffsetNanos = display.getAppVsyncOffsetNanos();
        long sfVsyncOffsetNanos = refreshPeriodNanos - (display.getPresentationDeadlineNanos() - ONE_MS_IN_NS);

        // Initialize UI

        SurfaceView surfaceView = findViewById(R.id.surface_view);
        surfaceView.getHolder().addCallback(this);

        mInfoOverlay = findViewById(R.id.info_overlay);
        mInfoOverlay.setBackgroundColor(0x80000000);

        buildChoreographerInfoGrid();
        buildSwappyStatsGrid();

        TextView appOffsetView = findViewById(R.id.app_offset);
        appOffsetView.setText(String.format(Locale.US, "App Offset: %.1f ms", appVsyncOffsetNanos / (float) ONE_MS_IN_NS));
        TextView sfOffsetView = findViewById(R.id.sf_offset);
        sfOffsetView.setText(String.format(Locale.US, "SF Offset: %.1f ms", sfVsyncOffsetNanos / (float) ONE_MS_IN_NS));

        // Initialize the native renderer

        nInit();

        nSetPreference("refresh_period", String.valueOf(refreshPeriodNanos));
    }

    private void infoOverlayToggle() {
        if (mInfoOverlay == null) {
            return;
        }

        mInfoOverlayEnabled = !mInfoOverlayEnabled;
        if (mInfoOverlayEnabled) {
            mInfoOverlay.setVisibility(View.VISIBLE);
            mInfoOverlayButton.setIcon(R.drawable.ic_info_solid_white_24dp);
        } else {
            mInfoOverlay.setVisibility(View.INVISIBLE);
            mInfoOverlayButton.setIcon(R.drawable.ic_info_outline_white_24dp);
        }
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        MenuInflater inflater = getMenuInflater();
        inflater.inflate(R.menu.menu_orbit, menu);

        mInfoOverlayButton = menu.findItem(R.id.info_overlay_button);
        if (mInfoOverlayButton != null) {
            mInfoOverlayButton.setOnMenuItemClickListener((MenuItem item) -> {
                infoOverlayToggle();
                return true;
            });
        }

        MenuItem settingsButton = menu.findItem(R.id.settings_item);
        if (settingsButton != null) {
            settingsButton.setOnMenuItemClickListener((MenuItem) -> {
                Intent intent = new Intent();
                intent.setClass(getApplicationContext(), SettingsActivity.class);
                startActivity(intent);
                return true;
            });
        }

        return true;
    }

    @Override
    protected void onStart() {
        super.onStart();

        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(getApplicationContext());
        for (String key : sharedPreferences.getAll().keySet()) {
            if (key.equals("use_affinity")) {
                nSetPreference(key, sharedPreferences.getBoolean(key, true) ? "true" : "false");
                continue;
            } else if (key.equals("hot_pocket")) {
                nSetPreference(key, sharedPreferences.getBoolean(key, false) ? "true" : "false");
                continue;
            } else if (key.equals("use_auto_swap_interval")) {
                nSetAutoSwapInterval(sharedPreferences.getBoolean(key, true));
                continue;
            } else if (key.equals("workload")) {
                nSetWorkload(sharedPreferences.getInt(key, 0));
                continue;
            }
            nSetPreference(key, sharedPreferences.getString(key, null));
        }

        mIsRunning = true;
        nStart();
        Choreographer.getInstance().postFrameCallback(this);
    }

    @Override
    protected void onStop() {
        super.onStop();

        mIsRunning = false;
        nStop();
        clearChoreographerInfo();
    }

    private int deltaToBin(long delta) {
        long framePeriodNanos = 16666666;
        return (int) ((delta + framePeriodNanos / 2) / framePeriodNanos);
    }

    private void clearChoreographerInfo() {
        for (int i = 0; i < CHOREOGRAPHER_INFO_BIN_COUNT; ++i) {
            mArrivalBinsLastSecond[i] = 0;
            mArrivalBinsLastMinute[i] = 0;
            mTimestampBinsLastSecond[i] = 0;
            mTimestampBinsLastMinute[i] = 0;
        }
        mArrivalBinQueue.clear();
        mTimestampBinQueue.clear();
    }

    private void updateChoregrapherInfoBin(int row, int bin, int value) {
        if (value == mLastChoreographerInfoValues[row - 1][bin]) {
            return;
        }

        mLastChoreographerInfoValues[row - 1][bin] = value;
        mChoreographerInfoGrid[row][bin + 1].setText(String.valueOf(value));
    }

    private void updateSwappyStatsBin(int row, int bin, int value) {
        if (value == mLastSwappyStatsValues[row - 1][bin]) {
            return;
        }

        mLastSwappyStatsValues[row - 1][bin] = value;
        mSwappyGrid[row][bin + 1].setText(String.valueOf(value) + "%");
    }

    private void dumpBins() {
        Trace.beginSection("dumpBins");

        Trace.beginSection("addToQueues");
        mArrivalBinQueue.add(mArrivalBinsLastSecond.clone());
        mTimestampBinQueue.add(mTimestampBinsLastSecond.clone());
        Trace.endSection();

        Trace.beginSection("updateMinuteBins");
        for (int bin = 0; bin < CHOREOGRAPHER_INFO_BIN_COUNT; ++bin) {
            mArrivalBinsLastMinute[bin] += mArrivalBinsLastSecond[bin];
            mTimestampBinsLastMinute[bin] += mTimestampBinsLastSecond[bin];
        }
        Trace.endSection();

        Trace.beginSection("pruneQueue");
        if (mArrivalBinQueue.size() > 60) {
            int[] oldestArrivalBin = mArrivalBinQueue.remove();
            int[] oldestTimestampBin = mTimestampBinQueue.remove();
            for (int bin = 0; bin < CHOREOGRAPHER_INFO_BIN_COUNT; ++bin) {
                mArrivalBinsLastMinute[bin] -= oldestArrivalBin[bin];
                mTimestampBinsLastMinute[bin] -= oldestTimestampBin[bin];
            }
        }
        Trace.endSection();

        Trace.beginSection("updateInfoGrid");
        for (int bin = 0; bin < CHOREOGRAPHER_INFO_BIN_COUNT; ++bin) {
            updateChoregrapherInfoBin(1, bin, mArrivalBinsLastSecond[bin]);
            updateChoregrapherInfoBin(2, bin, mTimestampBinsLastSecond[bin]);
            updateChoregrapherInfoBin(3, bin, mArrivalBinsLastMinute[bin]);
            updateChoregrapherInfoBin(4, bin, mTimestampBinsLastMinute[bin]);
        }
        Trace.endSection();

        Trace.beginSection("updateSwappyStatsGrid");
        for (int stat = 0; stat < 4; ++stat) {
            for (int bin = 0; bin < SWAPPY_STATS_BIN_COUNT; ++bin) {
                updateSwappyStatsBin(stat +1, bin, nGetSwappyStats(stat, bin));
            }
        }
        TextView appOffsetView = findViewById(R.id.swappy_stats);
        appOffsetView.setText(String.format(Locale.US, "SwappyStats: %d Total Frames", nGetSwappyStats(-1, 0)));
        Trace.endSection();

        Trace.beginSection("clearSecondBins");
        for (int bin = 0; bin < CHOREOGRAPHER_INFO_BIN_COUNT; ++bin) {
            mArrivalBinsLastSecond[bin] = 0;
            mTimestampBinsLastSecond[bin] = 0;
        }
        Trace.endSection();

        Trace.endSection();
    }

    @Override
    public void doFrame(long frameTimeNanos) {
        Trace.beginSection("doFrame");

        TextView fpsView = findViewById(R.id.fps);
        fpsView.setText(String.format(Locale.US, "FPS: %.1f", nGetAverageFps()));

        long now = System.nanoTime();

        if (mIsRunning) {
            Trace.beginSection("Requesting callback");
            Choreographer.getInstance().postFrameCallback(this);
            Trace.endSection();
        }

        long arrivalDelta = now - mLastArrivalTime;
        long timestampDelta = now - mLastFrameTimestamp;
        mLastArrivalTime = now;
        mLastFrameTimestamp = frameTimeNanos;

        mArrivalBinsLastSecond[Math.min(deltaToBin(arrivalDelta), mArrivalBinsLastSecond.length - 1)] += 1;
        mTimestampBinsLastSecond[Math.min(deltaToBin(timestampDelta), mTimestampBinsLastSecond.length - 1)] += 1;

        if (now - mLastDumpTime > 1000000000) {
            dumpBins();
            // Trim off excess precision so we don't drift forward over time
            mLastDumpTime = now - (now % 1000000000);
        }

        Trace.endSection();
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        // Do nothing here, waiting for surfaceChanged instead
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        Surface surface = holder.getSurface();
        nSetSurface(surface, width, height);
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        nClearSurface();
    }

    public native void nInit();
    public native void nSetSurface(Surface surface, int width, int height);
    public native void nClearSurface();
    public native void nStart();
    public native void nStop();
    public native void nSetPreference(String key, String value);
    public native void nSetWorkload(int load);
    public native void nSetAutoSwapInterval(boolean enabled);
    public native float nGetAverageFps();
    public native int nGetSwappyStats(int stat, int bin);

    private MenuItem mInfoOverlayButton;

    private LinearLayout mInfoOverlay;
    private final TextView[][] mChoreographerInfoGrid = new TextView[5][7];
    private final int[][] mLastChoreographerInfoValues = new int[4][6];

    private final TextView[][] mSwappyGrid = new TextView[5][7];
    private final int[][] mLastSwappyStatsValues = new int[4][6];

    private boolean mIsRunning;
    private boolean mInfoOverlayEnabled = false;

    private final ExecutorService mChoreographerExecutor = Executors.newSingleThreadExecutor();
    private final Handler mUIThreadHandler = new Handler(Looper.getMainLooper());

    private static final int CHOREOGRAPHER_INFO_BIN_COUNT = 6;
    private static final int SWAPPY_STATS_BIN_COUNT = 6;
    private long mLastDumpTime;
    private long mLastArrivalTime;
    private long mLastFrameTimestamp;
    private final int[] mArrivalBinsLastSecond = new int[CHOREOGRAPHER_INFO_BIN_COUNT];
    private final int[] mArrivalBinsLastMinute = new int[CHOREOGRAPHER_INFO_BIN_COUNT];
    private final Queue<int[]> mArrivalBinQueue = new ArrayDeque<>(60);
    private final int[] mTimestampBinsLastSecond = new int[CHOREOGRAPHER_INFO_BIN_COUNT];
    private final int[] mTimestampBinsLastMinute = new int[CHOREOGRAPHER_INFO_BIN_COUNT];
    private final Queue<int[]> mTimestampBinQueue = new ArrayDeque<>(60);
}