package org.linaro.iasenov.benchmarkframework;

import android.app.Activity;
import android.app.AlertDialog;
import android.app.ProgressDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.res.AssetManager;
import android.graphics.Color;
import android.graphics.Typeface;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.provider.MediaStore;
import android.support.v7.app.AppCompatActivity;
import android.text.Html;
import android.text.method.ScrollingMovementMethod;
import android.util.DisplayMetrics;
import android.util.Log;
import android.util.TypedValue;
import android.view.View;
import android.view.Menu;
import android.view.MenuItem;
import android.view.Window;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.ListView;
import android.widget.Toast;
import android.widget.TextView;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.lang.reflect.Method;
import java.math.BigInteger;
import java.nio.channels.FileChannel;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.List;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private String TAG = "BenchmarkFramework";

    private Button mStartButton;
    private Button mStartAutoButton;
    private Button mSaveButton;
    private Button mInfo;
    private ListView mListView;
    private TextView mDisplayDetails;

    private String mSelectedTest = "";
    private String mSelectedClassTest = "";
    private String autoTestFileNameIdentifier = "Default";
    private String mTestResult = "";
    private String mAllTestsResult = "";
    private String PACKAGE_NAME;
    private List<String> mAllTests;
    private ArrayList selectedClassTests;

    private int nextTestIndex;
    private int allTestsCount;
    private int numberOfCheckedTests = 0;

    private boolean isAuto = false;
    private boolean isSelected = false;
    public boolean isTempLogFileNeeded = false;

    private Context mContext;

    private static int pixWide;
    private static int pixHigh;
    private static int testDone = 0;
    public static String LOG_PATH = "";
    public static String EXECUTABLE_PATH = "";
    public static Activity mActivity;

    private Typeface tf = Typeface.create("monospace", 0);

    public File autoTestFile; //file for auto saving tests results(when isAuto);

    final String[] classNameTestItems = new String[7];
    public ArrayAdapter listAdapter;



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

        mContext = getApplicationContext();

        mActivity = this;

        PACKAGE_NAME = getApplicationContext().getPackageName();

        mStartButton = (Button)findViewById(R.id.startButton);
        mStartButton.setOnClickListener(this);

        mStartAutoButton = (Button)findViewById(R.id.startAutoButton);
        mStartAutoButton.setOnClickListener(this);

        mSaveButton = (Button)findViewById(R.id.saveButton);
        mSaveButton.setOnClickListener(this);

        mInfo = (Button)findViewById(R.id.infoButton);
        mInfo.setOnClickListener(this);

        mListView = (ListView) findViewById(R.id.tests_list_view);

        mDisplayDetails = (TextView)findViewById(R.id.displayDetails);
        DisplayMetrics metrics = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(metrics);
        mDisplayDetails.setTypeface(tf);

        pixHigh = metrics.heightPixels;
        pixWide = metrics.widthPixels;
        testDone = 0;


        int pixMin = pixWide;
        if (pixHigh < pixMin) pixMin = pixHigh;

        mDisplayDetails.setTextSize(TypedValue.COMPLEX_UNIT_PX, getPixels(pixMin));

        mDisplayDetails.setTextColor(Color.rgb(102, 255, 51));
        mDisplayDetails.setBackgroundColor(Color.BLACK);

        mDisplayDetails.setMovementMethod(new ScrollingMovementMethod());

        LOG_PATH = getFilesDir() + "/logss" + "/tmpLog.txt";
        EXECUTABLE_PATH = getFilesDir() + "/executable_file";

        classNameTestItems[0] = "Test1";
        classNameTestItems[1] = "Test2";
        classNameTestItems[2] = "Test3";
        classNameTestItems[3] = "Test4";
        classNameTestItems[4] = "Test5";
        classNameTestItems[5] = "Test6";
        classNameTestItems[6] = "Test7";



        String[] displayNames = new String[7];
        displayNames[0] = "MemSpeed";
        displayNames[1] = "RandMem";
        displayNames[2] = "Linaro-Libc-Bench";
        displayNames[3] = "Linaro-StringBench";
        displayNames[4] = "Linaro-Harness";
        displayNames[5] = "Linaro-Dhrystone";
        displayNames[6] = "Iozone";

        listAdapter = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_checked, displayNames);

        //ArrayAdapter adapter = new ArrayAdapter(this, android.R.layout.simple_list_item_1, displayNames);
        mListView.setAdapter(listAdapter);

        mListView.setChoiceMode(2); //multiple choice

        mListView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
            @Override
            public void onItemClick(AdapterView<?> adapterView, View view, int i, long l) {


                //mSelectedTest = (mListView.getItemAtPosition(i)).toString();
                //mSelectedClassTest = classNameTestItems[i];

                //Log.i(TAG, "View: "+mListView.getItemAtPosition(i).toString());
                //Log.i(TAG, "IsChecked: " + mListView.isItemChecked(i));

                if(mListView.isItemChecked(i)) {
                    numberOfCheckedTests++;
                }else{
                    numberOfCheckedTests--;
                }
            }
        });

    }

    //**********************************************************************************************
    @Override
    public void onResume(){
        super.onResume();
        // put your code here...

    }

    //**********************************************************************************************
    //Load benchmarks libraries when benchmark test is integrated as (*.so)
    //**********************************************************************************************
    static
    {
        System.loadLibrary("memspeedlib");
        System.loadLibrary("randmemlib");
        //System.loadLibrary("cbench");
        //System.loadLibrary("stringbench");
        //System.loadLibrary("harness");
    }


    //**********************************************************************************************
    @Override
    public void onClick(View v)
    {

        if(v.getId() == R.id.startButton && numberOfCheckedTests > 0)
        {
            isAuto = false;
            isSelected = true;

            //mDisplayDetails.setText(mSelectedTest + " is running please wait...");

            if(mSelectedClassTest.equals("Test4"))
            {
                isTempLogFileNeeded = true;
            }else
            {
                isTempLogFileNeeded = false;
            }

            runTests();

        }
        else if(v.getId() == R.id.startButton && numberOfCheckedTests == 0)
        {
            Toast.makeText(v.getContext(),"Please select test...",
                    Toast.LENGTH_SHORT).show();
        }
        else if(v.getId() == R.id.saveButton && testDone==1)
        {
            saveUIResultToFile();
        }
        else if(v.getId() == R.id.saveButton && testDone==0)
        {
            Toast.makeText(v.getContext(),"No results for save",
                    Toast.LENGTH_SHORT).show();
        }else if(v.getId() == R.id.startAutoButton)
        {
            isAuto = true;
            isSelected = false;
            runTests();

        }else if(v.getId() == R.id.infoButton)
        {
            String info = "[RUN TEST]: Run selected tests<br><br> [RUN AUTO]: Run all tests in row and save results to file automatically<br><br> [SAVE]: Save result shown on UI (display)";

            createAlertDialog("Help", info);
        }
    }



    //**********************************************************************************************
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
            getMenuInflater().inflate(R.menu.menu_main, menu);
        return true;
    }



    //**********************************************************************************************
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        //noinspection SimplifiableIfStatement
        if (id == R.id.action_settings) {
            return true;
        }

        return super.onOptionsItemSelected(item);
    }

    private void displayResult(String result)
    {
        mDisplayDetails.setText(result);
    }
    //**********************************************************************************************



    //**********************************************************************************************
    //Calculate best text size depends on pixels
    //**********************************************************************************************
    public int getPixels(int pixMin)
    {
        int pixels = 11;

        if (pixMin < 401)
        {
            pixels = 12;
        }
        else if (pixMin < 451)
        {
            pixels = 14;
        }
        else if (pixMin < 501)
        {
            pixels = 15;
        }
        else if (pixMin < 551)
        {
            pixels = 16;
        }
        else if (pixMin < 601)
        {
            pixels = 18;
        }
        else if (pixMin < 651)
        {
            pixels = 20;
        }
        else if (pixMin < 721)
        {
            pixels = 22;
        }
        else if (pixMin < 751)
        {
            pixels = 23;
        }
        else if (pixMin < 801)
        {
            pixels = 24;
        }
        else if (pixMin < 851)
        {
            pixels = 26;
        }
        else if (pixMin < 901)
        {
            pixels = 28;
        }
        else if (pixMin < 951)
        {
            pixels = 30;
        }
        else
        {
            pixels = 32;
        }

        return pixels;
    }



    //**********************************************************************************************
    //Save "mDisplayDetails" text to file
    //**********************************************************************************************
    public void saveUIResultToFile(){

            File dir = new File (getFilesDir() + "/download");
            dir.mkdirs();
            File file = new File(dir, "testUIData.txt");

            try {
                FileOutputStream f = new FileOutputStream(file);
                PrintWriter pw = new PrintWriter(f);
                pw.println(mDisplayDetails.getText().toString());
                pw.flush();
                pw.close();
                f.close();

                Log.i("IVO", getFilesDir() + " FilePath: " + file.getAbsolutePath());
                Toast.makeText(mContext,"Result was saved to file: " + file.getAbsolutePath(),
                        Toast.LENGTH_LONG).show();

            } catch (FileNotFoundException e) {
                e.printStackTrace();

            } catch (IOException e) {
                e.printStackTrace();
            }

    }

    //**********************************************************************************************
    //Save results from Auto tests to text file with random name every time
    //**********************************************************************************************
    public void saveAutoTestResultToFile(){

        File dir = new File (getFilesDir() + "/download");
        dir.mkdirs();
        autoTestFile = new File(dir, "testLogcatData_"+autoTestFileNameIdentifier+".txt");


        try {
            FileOutputStream f = new FileOutputStream(autoTestFile,true);
            PrintWriter pw = new PrintWriter(f);
            pw.println(mTestResult/*mDisplayDetails.getText().toString()*/);
            pw.flush();
            pw.close();
            f.close();

            Log.i("IVO", getFilesDir() + " FilePath: " + autoTestFile.getAbsolutePath());
            //Toast.makeText(mContext,"Result was saved to file: " + file.getAbsolutePath(),
             //       Toast.LENGTH_LONG).show();


        } catch (FileNotFoundException e) {
            e.printStackTrace();

        } catch (IOException e) {
            e.printStackTrace();
        }

    }


    //**********************************************************************************************
    //Run tests
    //**********************************************************************************************
    public void runTests() {
        nextTestIndex = 0;
        allTestsCount = 0;
        mAllTests = new ArrayList<String>();
        selectedClassTests = new ArrayList<String>();
        mAllTestsResult="";
        selectedClassTests.clear();
        mAllTests.clear();



        mDisplayDetails.scrollTo(0,0);


        if(isAuto)
        {
            for (int i = 0; i < mListView.getCount(); i++) {
                mAllTests.add((mListView.getItemAtPosition(i)).toString());
            }
        }

        if(isSelected)
        {
            for (int i = 0; i < mListView.getCount(); i++) {

                if(mListView.isItemChecked(i)) {
                    mAllTests.add((mListView.getItemAtPosition(i)).toString());
                    selectedClassTests.add(classNameTestItems[i]);
                }
            }
        }

        allTestsCount = mAllTests.size();
        if(isAuto)      Log.i(TAG, "autoTest:" + allTestsCount);
        if(isSelected)  Log.i(TAG, "Selected tests:" + allTestsCount);

        if (mAllTests.size() > 0){

            SecureRandom random = new SecureRandom();
            autoTestFileNameIdentifier = new BigInteger(11, random).toString(32);


            for(int i = 0; i < allTestsCount; i++) {

                isTempLogFileNeeded = false;//make it false for now

                if (nextTestIndex < allTestsCount) {

                    if (isAuto) {
                        mSelectedTest = mAllTests.get(nextTestIndex);
                        mSelectedClassTest = classNameTestItems[nextTestIndex];
                    }

                    if (isSelected){
                        mSelectedTest = mAllTests.get(nextTestIndex).toString();
                        mSelectedClassTest = selectedClassTests.get(nextTestIndex).toString();
                    }

                    String localSelectedTest = mSelectedTest;
                    String localSelectedClassTest = mSelectedClassTest;

                    //if(!localSelectedClassTest.equals("Test4")) { //Test4 is too long so stop it for faster debugging

                    AsyncTaskRunner runner = new AsyncTaskRunner(localSelectedTest, localSelectedClassTest);
                    //runner.execute(mSelectedTest);
                    runner.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR, localSelectedTest);
                    //}
                    nextTestIndex++;
                }
            }
        }
    }



    //**********************************************************************************************
    //Can Use this method when benchmark test take a lot of time and logcat dev/log/main ring buffer is overloaded
    //Reads only app logs
    //**********************************************************************************************
    public Process writeLogcatToFile(File tempLogFile) {

        Log.i(TAG, "writeLogcatToFile");
        Process process = null;

        try {
            Runtime.getRuntime().exec(new String[]{"logcat", "-c"});

            File dir = new File(getFilesDir() + "/logss");
            dir.mkdirs();
            tempLogFile = new File(dir, "tmpLog.txt");
            tempLogFile.delete();
            tempLogFile = new File(dir, "tmpLog.txt");
            process = Runtime.getRuntime().exec("logcat -f " + tempLogFile.getAbsolutePath());



        } catch (Exception e1) {
        e1.printStackTrace();
        }

        return process;
    }
    //**********************************************************************************************

    public void createAlertDialog(String title, String message){
        AlertDialog alertDialog = new AlertDialog.Builder(MainActivity.this).create();
        alertDialog.setTitle(title);
        alertDialog.setMessage(Html.fromHtml(message));
        alertDialog.setButton(AlertDialog.BUTTON_NEUTRAL, "OK",
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int which) {
                        dialog.dismiss();
                    }
                });
        alertDialog.show();
    }
    //**********************************************************************************************

    //**********************************************************************************************
    //Async task for background test processing
    //**********************************************************************************************
    public class AsyncTaskRunner extends AsyncTask<String, String, String> {

        private String resp;
        ProgressDialog progressDialog;
        String selectedTest;
        String selectedClassTest;


        public AsyncTaskRunner(String test, String classTest) {
            super();
            selectedTest = test;
            selectedClassTest = classTest;
        }


        @Override
        protected String doInBackground(String... params) {

            publishProgress(selectedTest, selectedClassTest);

            try {

                testDone = 0;

                Class thisClass = Class.forName(PACKAGE_NAME + "." + selectedClassTest);
                Object iClass = thisClass.newInstance();
                Method thisMethod = thisClass.getMethod("startBenchmark", Integer.TYPE);

                mTestResult = (String) (thisMethod.invoke(iClass, 1));
                mAllTestsResult = mAllTestsResult +"\n\n"+ mTestResult;

                if(isAuto) {
                    saveAutoTestResultToFile();
                }else
                {
                    saveAutoTestResultToFile();
                }
                testDone = 1;


            } catch (Exception e) {
                e.printStackTrace();
                resp = e.getMessage();
            }
            return selectedClassTest;
        }


        @Override
        protected void onPostExecute(String result) {
            // execution of result of Long time consuming operation
            progressDialog.dismiss();
            //finalResult.setText(result);

            //displayResult(mTestResult); //UI display
            Log.i(TAG, mTestResult);    //adb logcat display

            String endTest="";
            if(isAuto) {
                endTest = classNameTestItems[allTestsCount - 1];
            }else
            {
                endTest = selectedClassTests.get(allTestsCount - 1).toString();
            }

            if(result.equals(endTest)) { //if last one is finished

                displayResult(mAllTestsResult);//UI display

                String filepath = "<font color=\"blue\">"+autoTestFile.getAbsolutePath()+"</font>";
                createAlertDialog("File with results created", filepath);
            }
        }


        @Override
        protected void onPreExecute() {

            Log.i(TAG, "selectedTest:" + selectedTest);

            //if(isAuto) {
                mDisplayDetails.setText(selectedTest + " is running please wait...");
            //}
        }


        @Override
        protected void onProgressUpdate(String... text) {

            mDisplayDetails.setText(text[0] + " is running please wait...");


            String extraText = "";
            if(text[1].equals(("Test4"))) //set some extra text for this test to inform user for longer wait.
            {
                extraText = "\n\nNote: This test can take more than 30 min. so be patient...";
            }

            progressDialog = new ProgressDialog(MainActivity.this);
            progressDialog.setTitle("ProgressDialog");
            progressDialog.setMessage(text[0] + " is running please wait..." + extraText);
            progressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
            progressDialog.setCanceledOnTouchOutside(false);

            // Put a cancel button in progress dialog
            /* TODO: Set Cancel button for cancelling the test
            progressDialog.setButton(DialogInterface.BUTTON_NEGATIVE, "Cancel", new DialogInterface.OnClickListener() {
                // Set a click listener for progress dialog cancel button
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    // dismiss the progress dialog
                    progressDialog.dismiss();
                    // Tell the system about cancellation
                    //isCanceled = true;
                }
            });
            */

            progressDialog.show();


            if(isAuto) {

                int mActivePosition = 0;

                mListView.clearChoices();
                listAdapter.notifyDataSetChanged();

                for (String className : classNameTestItems)
                {
                    if(className.equals(text[1]))
                    {
                        //Click on the current test
                        mListView.performItemClick(
                                mListView.getAdapter().getView(mActivePosition, null, null),
                                mActivePosition,
                                mListView.getAdapter().getItemId(mActivePosition));
                    }
                    mActivePosition++;
                }
            }
        }

    //**********************************************************************************************
    }//AsyncTaskRunner
    //**********************************************************************************************


//**********************************************************************************************
}//MainActivity
//**********************************************************************************************