package com.app.ax;


import android.app.Activity;
import android.app.AlertDialog;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.widget.Button;
import android.widget.TextView;

import android.view.View;
import android.view.View.OnClickListener;


import android.graphics.Color;
import android.hardware.SensorManager;
import android.hardware.SensorEventListener;

import android.hardware.SensorEvent;
import android.hardware.Sensor;

import java.util.ArrayList;
import java.util.List;

import com.android.future.usb.UsbAccessory;
import com.android.future.usb.UsbManager;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

import android.widget.Toast;
import android.content.Context;

import org.achartengine.*;
import org.achartengine.chart.PointStyle;
import org.achartengine.model.XYMultipleSeriesDataset;
import org.achartengine.model.XYSeries;
import org.achartengine.renderer.XYMultipleSeriesRenderer;
import org.achartengine.renderer.XYSeriesRenderer;

public class AxActivity extends Activity  implements SensorEventListener, OrientationListener {


    private UsbManager mUsbManager;
        UsbAccessory mAccessory;
        FileInputStream mInputStream;
        FileOutputStream mOutputStream;

    SensorManager mSensorManager;
    Sensor mAccelerometerSensor;

    TextView X;
    TextView Y;
    TextView Z;
    TextView C;

    float gravity;
    float linear_acceleration;

    Axellerometer a = new Axellerometer();

    double margins[] = {0, 0};
    List<List<Double>> mValues;

    Button mShowButton;
    Button mStartButton;

    boolean mIsRecording = true;

    OnClickListener mStartButtonListener = new OnClickListener() {

        public void onClick(View v) {


                mValues.get(SensorManager.DATA_X).clear();
                mValues.get(SensorManager.DATA_Y).clear();
                mValues.get(SensorManager.DATA_Z).clear();
                margins[0] = 0;
                margins[1] = 0;

        }
    };

    OnClickListener mShowButtonListener = new View.OnClickListener() {


            public void onClick(View v) {
                try
                {
                    Intent intent = getChartIntent();
                    startActivity(intent);
                }
                catch (Exception e) {
                    new AlertDialog.Builder(AxActivity.this)
                        .setTitle("Error")
                        .setMessage(e.getMessage())
                        .create()
                        .show();
                }

            }
        };


        Intent getChartIntent() {
            int [] colors = new int[] { Color.RED, Color.GREEN, Color.BLUE };
            PointStyle[] styles = new PointStyle[] { PointStyle.POINT, PointStyle.POINT, PointStyle.POINT };
            XYMultipleSeriesRenderer renderer = buildRenderer(colors, styles);
            setChartSettings(renderer, "Sensor Values", "Index", "Value",
                    0,
                    mValues.get(SensorManager.DATA_X).size(),
                    margins[0] * 1.5,
                    margins[1] * 1.5,
                Color.GRAY, Color.LTGRAY);
            return ChartFactory.getLineChartIntent(this, buildDataset(), renderer);
        }

        protected void setChartSettings(XYMultipleSeriesRenderer renderer, String title, String xTitle,
                  String yTitle, double xMin, double xMax, double yMin, double yMax, int axesColor,
                  int labelsColor) {

                    renderer.setChartTitle(title);
                    renderer.setXTitle(xTitle);
                    renderer.setYTitle(yTitle);
                    renderer.setXAxisMin(xMin);
                    renderer.setXAxisMax(xMax);
                    renderer.setYAxisMin(yMin);
                    renderer.setYAxisMax(yMax);
                    renderer.setAxesColor(axesColor);
                    renderer.setLabelsColor(labelsColor);
              }

        protected XYMultipleSeriesRenderer buildRenderer(int[] colors, PointStyle[] styles) {
            XYMultipleSeriesRenderer renderer = new XYMultipleSeriesRenderer();
            int length = colors.length;
            for (int i = 0; i < length; i++) {
              XYSeriesRenderer r = new XYSeriesRenderer();
              r.setColor(colors[i]);
              r.setPointStyle(styles[i]);
              renderer.addSeriesRenderer(r);
            }
            return renderer;
          }

        private void recordSensorValue(SensorEvent event) {
            double value;
            for(int i = SensorManager.DATA_X; i <= SensorManager.DATA_Z; i++)
            {
                value = (double)event.values[i];
                margins[0] = Math.min(margins[0], value);
                margins[1] = Math.max(margins[1], value);
                mValues.get(i).add(value);
            }
        }


        XYMultipleSeriesDataset buildDataset() {

            XYMultipleSeriesDataset result = new XYMultipleSeriesDataset();
            XYSeries xSeries = new XYSeries("X");
            XYSeries ySeries = new XYSeries("Y");
            XYSeries zSeries = new XYSeries("Z");

            int count = mValues.get(SensorManager.DATA_X).size();
            for(int i = 0; i < count; i++)
            {
                xSeries.add(i, mValues.get(SensorManager.DATA_X).get(i));
                ySeries.add(i, mValues.get(SensorManager.DATA_Y).get(i));
                zSeries.add(i, mValues.get(SensorManager.DATA_Z).get(i));
            }

            result.addSeries(xSeries);
            result.addSeries(ySeries);
            result.addSeries(zSeries);

            return result;
        }


        private static Context CONTEXT;

       /** Called when the activity is first created. */
       @Override
      public void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);

           setContentView(R.layout.main);

            mValues = new ArrayList<List<Double>>();
            mValues.add(new ArrayList<Double>());
            mValues.add(new ArrayList<Double>());
            mValues.add(new ArrayList<Double>());

            mSensorManager = (SensorManager)getSystemService(Context.SENSOR_SERVICE);

            X = (TextView)findViewById(R.id.x);
            Y = (TextView)findViewById(R.id.y);
            Z = (TextView)findViewById(R.id.z);
            C = (TextView)findViewById(R.id.c);

            mShowButton = (Button)findViewById(R.id.button_show);
            mShowButton.setOnClickListener(mShowButtonListener);

            mStartButton = (Button)findViewById(R.id.button_start);
            mStartButton.setOnClickListener(mStartButtonListener);

            List<Sensor> sensors = mSensorManager.getSensorList(Sensor.TYPE_ALL);

            if(sensors.size() > 0){

                for (Sensor sensor : sensors) {
                    switch(sensor.getType())
                    {
                    case Sensor.TYPE_ACCELEROMETER:
                        if(mAccelerometerSensor == null) mAccelerometerSensor = sensor;
                        break;
                    default:
                        break;
                    }
                }
            }

            CONTEXT = this;
       }


       public void clog(View view) {

          TextView text  = (TextView) findViewById(R.id.toptext);

          text.setText( String.valueOf(a.getNumber()));

          System.out.format( String.valueOf(a.getNumber()) + "%n");
       }


       @Override
        protected void onPause() {
            mSensorManager.unregisterListener(this);
            super.onPause();

        }


       @Override
        protected void onResume() {
            super.onResume();
            mSensorManager.registerListener(this, mAccelerometerSensor, SensorManager.SENSOR_DELAY_GAME);


            if (OrientationManager.isSupported()) {
                OrientationManager.startListening(this);
            }

        }


       public void onAccuracyChanged(Sensor sensor, int accuracy) {

        }


       public void onSensorChanged(SensorEvent event) {
            float [] values = event.values;
            switch(event.sensor.getType())
            {
            case Sensor.TYPE_ACCELEROMETER:
                {


                    if(mIsRecording)
                    {
                        recordSensorValue(event);
                    }


                    float alpha = 0.8f;



                    gravity = alpha * gravity + (1 - alpha) *  Float.valueOf(event.values[1]);
                    linear_acceleration= event.values[1] - gravity;

                    float min = 0;
                    float max = 9.7f;
                    float g = 9.81f;
                    double angle;

                    //angle = Math.asin(linear_acceleration / g);

                    angle =  -event.values[1] / 9.82F;


                   float ta = (event.values[1] * 90)/max;

                    X.setText(String.format("%1.3f", linear_acceleration));
                    Y.setText(String.format("%1.3f", event.values[SensorManager.DATA_Y]));
                    //Z.setText(String.valueOf(angle));
                    //C.setText(String.valueOf(ta));



                    //int sensor = event.type;
                    //float[] values = event.values;
                    int i;
                    StringBuffer str=new StringBuffer();
                    // do something with the sensor data
                    TextView text = (TextView) findViewById(R.id.my_text);
                    float[] R = new float[9]; // rotation matrix
                    float[] magnetic = new float[3];
                    float[] orientation = new float[3];

                    magnetic[0]=0;
                    magnetic[1]=1;
                    magnetic[2]=0;


                        str.append(values[1]);
                        str.append(", ");


                    SensorManager.getRotationMatrix(R, null, values,   magnetic);
                    SensorManager.getOrientation(R, orientation);

                    orientation[1]*= 57.2957795f;

                    sendCommand((byte)1, (byte)1, (byte) orientation[1]);

                    str.append(orientation[1]);


                    text.setText(str);


                }
                break;
            }
        }




        protected void onDestroy() {
            super.onDestroy();
            if (OrientationManager.isListening()) {
                    OrientationManager.stopListening();
            }

        }

        public static Context getContext() {
                    return CONTEXT;
            }


            public void onOrientationChanged(float azimuth, float pitch, float roll) {
                    ((TextView) findViewById(R.id.azimuth)).setText(
                                    String.valueOf(azimuth));
                    ((TextView) findViewById(R.id.pitch)).setText(
                                    String.valueOf(pitch));
                    ((TextView) findViewById(R.id.roll)).setText(
                                    String.valueOf(roll));
            }


            public void onBottomUp() {
                    Toast.makeText(this, "Bottom UP", 1000).show();
            }


            public void onLeftUp() {
                    Toast.makeText(this, "Left UP", 1000).show();
            }


            public void onRightUp() {
                    Toast.makeText(this, "Right UP", 1000).show();
            }


            public void onTopUp() {
                    Toast.makeText(this, "Top UP", 1000).show();
            }




            // mActivity.sendCommand((byte)2, (byte)0, (byte)255)
            public void sendCommand(byte command, byte target, int value) {
                byte[] buffer = new byte[3];
                if (value > 255)
                        value = 255;

                buffer[0] = command;
                buffer[1] = target;
                buffer[2] = (byte) value;
                if (mOutputStream != null && buffer[1] != -1) {
                    try {
                        mOutputStream.write(buffer);

                        C.setText(String.valueOf(value));

                    } catch (IOException e) {

                        C.setText(String.valueOf("Usb write error"));
                        e.printStackTrace();
                    }
                }
            }


}