/*
 * Copyright (C) 2010 Google Inc.
 *
 * 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.googlecode.android_scripting.facade;

import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Bundle;

import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
import com.googlecode.android_scripting.rpc.Rpc;
import com.googlecode.android_scripting.rpc.RpcDefault;
import com.googlecode.android_scripting.rpc.RpcDeprecated;
import com.googlecode.android_scripting.rpc.RpcParameter;
import com.googlecode.android_scripting.rpc.RpcStartEvent;
import com.googlecode.android_scripting.rpc.RpcStopEvent;

import java.util.Arrays;
import java.util.List;

/**
 * Exposes the SensorManager related functionality. <br>
 * <br>
 * <b>Guidance notes</b> <br>
 * For reasons of economy the sensors on smart phones are usually low cost and, therefore, low
 * accuracy (usually represented by 10 bit data). The floating point data values obtained from
 * sensor readings have up to 16 decimal places, the majority of which are noise. On many phones the
 * accelerometer is limited (by the phone manufacturer) to a maximum reading of 2g. The magnetometer
 * (which also provides orientation readings) is strongly affected by the presence of ferrous metals
 * and can give large errors in vehicles, on board ship etc.
 * 
 * Following a startSensingTimed(A,B) api call sensor events are entered into the Event Queue (see
 * EventFacade). For the A parameter: 1 = All Sensors, 2 = Accelerometer, 3 = Magnetometer and 4 =
 * Light. The B parameter is the minimum delay between recordings in milliseconds. To avoid
 * duplicate readings the minimum delay should be 20 milliseconds. The light sensor will probably be
 * much slower (taking about 1 second to register a change in light level). Note that if the light
 * level is constant no sensor events will be registered by the light sensor.
 * 
 * Following a startSensingThreshold(A,B,C) api call sensor events greater than a given threshold
 * are entered into the Event Queue. For the A parameter: 1 = Orientation, 2 = Accelerometer, 3 =
 * Magnetometer and 4 = Light. The B parameter is the integer value of the required threshold level.
 * For orientation sensing the integer threshold value is in milliradians. Since orientation events
 * can exceed the threshold value for long periods only crossing and return events are recorded. The
 * C parameter is the required axis (XYZ) of the sensor: 0 = No axis, 1 = X, 2 = Y, 3 = X+Y, 4 = Z,
 * 5= X+Z, 6 = Y+Z, 7 = X+Y+Z. For orientation X = azimuth, Y = pitch and Z = roll. <br>
 * 
 * <br>
 * <b>Example (python)</b>
 * 
 * <pre>
 * import android, time
 * droid = android.Android()
 * droid.startSensingTimed(1, 250)
 * time.sleep(1)
 * s1 = droid.readSensors().result
 * s2 = droid.sensorsGetAccuracy().result
 * s3 = droid.sensorsGetLight().result
 * s4 = droid.sensorsReadAccelerometer().result
 * s5 = droid.sensorsReadMagnetometer().result
 * s6 = droid.sensorsReadOrientation().result
 * droid.stopSensing()
 * </pre>
 * 
 * Returns:<br>
 * s1 = {u'accuracy': 3, u'pitch': -0.47323511242866517, u'xmag': 1.75, u'azimuth':
 * -0.26701245009899138, u'zforce': 8.4718560000000007, u'yforce': 4.2495484000000001, u'time':
 * 1297160391.2820001, u'ymag': -8.9375, u'zmag': -41.0625, u'roll': -0.031366908922791481,
 * u'xforce': 0.23154590999999999}<br>
 * s2 = 3 (Highest accuracy)<br>
 * s3 = None ---(not available on many phones)<br>
 * s4 = [0.23154590999999999, 4.2495484000000001, 8.4718560000000007] ----(x, y, z accelerations)<br>
 * s5 = [1.75, -8.9375, -41.0625] -----(x, y, z magnetic readings)<br>
 * s6 = [-0.26701245009899138, -0.47323511242866517, -0.031366908922791481] ---(azimuth, pitch, roll
 * in radians)<br>
 * 
 * @author Damon Kohler (damonkohler@gmail.com)
 * @author Felix Arends (felix.arends@gmail.com)
 * @author Alexey Reznichenko (alexey.reznichenko@gmail.com)
 * @author Robbie Mathews (rjmatthews62@gmail.com)
 * @author John Karwatzki (jokar49@gmail.com)
 */
public class SensorManagerFacade extends RpcReceiver {
  private final EventFacade mEventFacade;
  private final SensorManager mSensorManager;

  private volatile Bundle mSensorReadings;

  private volatile Integer mAccuracy;
  private volatile Integer mSensorNumber;
  private volatile Integer mXAxis = 0;
  private volatile Integer mYAxis = 0;
  private volatile Integer mZAxis = 0;
  private volatile Integer mThreshing = 0;
  private volatile Integer mThreshOrientation = 0;
  private volatile Integer mXCrossed = 0;
  private volatile Integer mYCrossed = 0;
  private volatile Integer mZCrossed = 0;

  private volatile Float mThreshold;
  private volatile Float mXForce;
  private volatile Float mYForce;
  private volatile Float mZForce;

  private volatile Float mXMag;
  private volatile Float mYMag;
  private volatile Float mZMag;

  private volatile Float mLight;

  private volatile Double mAzimuth;
  private volatile Double mPitch;
  private volatile Double mRoll;

  private volatile Long mLastTime;
  private volatile Long mDelayTime;

  private SensorEventListener mSensorListener;

  public SensorManagerFacade(FacadeManager manager) {
    super(manager);
    mEventFacade = manager.getReceiver(EventFacade.class);
    mSensorManager = (SensorManager) manager.getService().getSystemService(Context.SENSOR_SERVICE);
  }

  @Rpc(description = "Starts recording sensor data to be available for polling.")
  @RpcStartEvent("sensors")
  public void startSensingTimed(
      @RpcParameter(name = "sensorNumber", description = "1 = All, 2 = Accelerometer, 3 = Magnetometer and 4 = Light") Integer sensorNumber,
      @RpcParameter(name = "delayTime", description = "Minimum time between readings in milliseconds") Integer delayTime) {
    mSensorNumber = sensorNumber;
    if (delayTime < 20) {
      delayTime = 20;
    }
    mDelayTime = (long) (delayTime);
    mLastTime = System.currentTimeMillis();
    if (mSensorListener == null) {
      mSensorListener = new SensorValuesCollector();
      mSensorReadings = new Bundle();
      switch (mSensorNumber) {
      case 1:
        for (Sensor sensor : mSensorManager.getSensorList(Sensor.TYPE_ALL)) {
          mSensorManager.registerListener(mSensorListener, sensor,
              SensorManager.SENSOR_DELAY_FASTEST);
        }
        break;
      case 2:
        for (Sensor sensor : mSensorManager.getSensorList(Sensor.TYPE_ACCELEROMETER)) {
          mSensorManager.registerListener(mSensorListener, sensor,
              SensorManager.SENSOR_DELAY_FASTEST);
        }
        break;
      case 3:
        for (Sensor sensor : mSensorManager.getSensorList(Sensor.TYPE_MAGNETIC_FIELD)) {
          mSensorManager.registerListener(mSensorListener, sensor,
              SensorManager.SENSOR_DELAY_FASTEST);
        }
        break;
      case 4:
        for (Sensor sensor : mSensorManager.getSensorList(Sensor.TYPE_LIGHT)) {
          mSensorManager.registerListener(mSensorListener, sensor,
              SensorManager.SENSOR_DELAY_FASTEST);
        }
      }
    }
  }

  @Rpc(description = "Records to the Event Queue sensor data exceeding a chosen threshold.")
  @RpcStartEvent("threshold")
  public void startSensingThreshold(

      @RpcParameter(name = "sensorNumber", description = "1 = Orientation, 2 = Accelerometer, 3 = Magnetometer and 4 = Light") Integer sensorNumber,
      @RpcParameter(name = "threshold", description = "Threshold level for chosen sensor (integer)") Integer threshold,
      @RpcParameter(name = "axis", description = "0 = No axis, 1 = X, 2 = Y, 3 = X+Y, 4 = Z, 5= X+Z, 6 = Y+Z, 7 = X+Y+Z") Integer axis) {
    mSensorNumber = sensorNumber;
    mXAxis = axis & 1;
    mYAxis = axis & 2;
    mZAxis = axis & 4;
    if (mSensorNumber == 1) {
      mThreshing = 0;
      mThreshOrientation = 1;
      mThreshold = ((float) threshold) / ((float) 1000);
    } else {
      mThreshing = 1;
      mThreshold = (float) threshold;
    }
    startSensingTimed(mSensorNumber, 20);
  }

  @Rpc(description = "Returns the most recently recorded sensor data.")
  public Bundle readSensors() {
    if (mSensorReadings == null) {
      return null;
    }
    synchronized (mSensorReadings) {
      return new Bundle(mSensorReadings);
    }
  }

  @Rpc(description = "Stops collecting sensor data.")
  @RpcStopEvent("sensors")
  public void stopSensing() {
    mSensorManager.unregisterListener(mSensorListener);
    mSensorListener = null;
    mSensorReadings = null;
    mThreshing = 0;
    mThreshOrientation = 0;
  }

  @Rpc(description = "Returns the most recently received accuracy value.")
  public Integer sensorsGetAccuracy() {
    return mAccuracy;
  }

  @Rpc(description = "Returns the most recently received light value.")
  public Float sensorsGetLight() {
    return mLight;
  }

  @Rpc(description = "Returns the most recently received accelerometer values.", returns = "a List of Floats [(acceleration on the) X axis, Y axis, Z axis].")
  public List<Float> sensorsReadAccelerometer() {
    synchronized (mSensorReadings) {
      return Arrays.asList(mXForce, mYForce, mZForce);
    }
  }

  @Rpc(description = "Returns the most recently received magnetic field values.", returns = "a List of Floats [(magnetic field value for) X axis, Y axis, Z axis].")
  public List<Float> sensorsReadMagnetometer() {
    synchronized (mSensorReadings) {
      return Arrays.asList(mXMag, mYMag, mZMag);
    }
  }

  @Rpc(description = "Returns the most recently received orientation values.", returns = "a List of Doubles [azimuth, pitch, roll].")
  public List<Double> sensorsReadOrientation() {
    synchronized (mSensorReadings) {
      return Arrays.asList(mAzimuth, mPitch, mRoll);
    }
  }

  @Rpc(description = "Starts recording sensor data to be available for polling.")
  @RpcDeprecated(value = "startSensingTimed or startSensingThreshhold", release = "4")
  public void startSensing(
      @RpcParameter(name = "sampleSize", description = "number of samples for calculating average readings") @RpcDefault("5") Integer sampleSize) {
    if (mSensorListener == null) {
      startSensingTimed(1, 220);
    }
  }

  @Override
  public void shutdown() {
    stopSensing();
  }

  private class SensorValuesCollector implements SensorEventListener {
    private final static int MATRIX_SIZE = 9;

    private final RollingAverage mmAzimuth;
    private final RollingAverage mmPitch;
    private final RollingAverage mmRoll;

    private float[] mmGeomagneticValues;
    private float[] mmGravityValues;
    private float[] mmR;
    private float[] mmOrientation;

    public SensorValuesCollector() {
      mmAzimuth = new RollingAverage();
      mmPitch = new RollingAverage();
      mmRoll = new RollingAverage();
    }

    private void postEvent() {
      mSensorReadings.putDouble("time", System.currentTimeMillis() / 1000.0);
      mEventFacade.postEvent("sensors", mSensorReadings.clone());
    }

    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {
      if (mSensorReadings == null) {
        return;
      }
      synchronized (mSensorReadings) {
        mSensorReadings.putInt("accuracy", accuracy);
        mAccuracy = accuracy;

      }
    }

    @Override
    public void onSensorChanged(SensorEvent event) {
      if (mSensorReadings == null) {
        return;
      }
      synchronized (mSensorReadings) {
        switch (event.sensor.getType()) {
        case Sensor.TYPE_ACCELEROMETER:
          mXForce = event.values[0];
          mYForce = event.values[1];
          mZForce = event.values[2];
          if (mThreshing == 0) {
            mSensorReadings.putFloat("xforce", mXForce);
            mSensorReadings.putFloat("yforce", mYForce);
            mSensorReadings.putFloat("zforce", mZForce);
            if ((mSensorNumber == 2) && (System.currentTimeMillis() > (mDelayTime + mLastTime))) {
              mLastTime = System.currentTimeMillis();
              postEvent();
            }
          }
          if ((mThreshing == 1) && (mSensorNumber == 2)) {
            if ((Math.abs(mXForce) > mThreshold) && (mXAxis == 1)) {
              mSensorReadings.putFloat("xforce", mXForce);
              postEvent();
            }

            if ((Math.abs(mYForce) > mThreshold) && (mYAxis == 2)) {
              mSensorReadings.putFloat("yforce", mYForce);
              postEvent();
            }

            if ((Math.abs(mZForce) > mThreshold) && (mZAxis == 4)) {
              mSensorReadings.putFloat("zforce", mZForce);
              postEvent();
            }
          }

          mmGravityValues = event.values.clone();
          break;
        case Sensor.TYPE_MAGNETIC_FIELD:
          mXMag = event.values[0];
          mYMag = event.values[1];
          mZMag = event.values[2];
          if (mThreshing == 0) {
            mSensorReadings.putFloat("xMag", mXMag);
            mSensorReadings.putFloat("yMag", mYMag);
            mSensorReadings.putFloat("zMag", mZMag);
            if ((mSensorNumber == 3) && (System.currentTimeMillis() > (mDelayTime + mLastTime))) {
              mLastTime = System.currentTimeMillis();
              postEvent();
            }
          }
          if ((mThreshing == 1) && (mSensorNumber == 3)) {
            if ((Math.abs(mXMag) > mThreshold) && (mXAxis == 1)) {
              mSensorReadings.putFloat("xforce", mXMag);
              postEvent();
            }
            if ((Math.abs(mYMag) > mThreshold) && (mYAxis == 2)) {
              mSensorReadings.putFloat("yforce", mYMag);
              postEvent();
            }
            if ((Math.abs(mZMag) > mThreshold) && (mZAxis == 4)) {
              mSensorReadings.putFloat("zforce", mZMag);
              postEvent();
            }
          }
          mmGeomagneticValues = event.values.clone();
          break;
        case Sensor.TYPE_LIGHT:
          mLight = event.values[0];
          if (mThreshing == 0) {
            mSensorReadings.putFloat("light", mLight);
            if ((mSensorNumber == 4) && (System.currentTimeMillis() > (mDelayTime + mLastTime))) {
              mLastTime = System.currentTimeMillis();
              postEvent();
            }
          }
          if ((mThreshing == 1) && (mSensorNumber == 4)) {
            if (mLight > mThreshold) {
              mSensorReadings.putFloat("light", mLight);
              postEvent();
            }
          }
          break;

        }
        if (mSensorNumber == 1) {
          if (mmGeomagneticValues != null && mmGravityValues != null) {
            if (mmR == null) {
              mmR = new float[MATRIX_SIZE];
            }
            if (SensorManager.getRotationMatrix(mmR, null, mmGravityValues, mmGeomagneticValues)) {
              if (mmOrientation == null) {
                mmOrientation = new float[3];
              }
              SensorManager.getOrientation(mmR, mmOrientation);
              mmAzimuth.add(mmOrientation[0]);
              mmPitch.add(mmOrientation[1]);
              mmRoll.add(mmOrientation[2]);

              mAzimuth = mmAzimuth.get();
              mPitch = mmPitch.get();
              mRoll = mmRoll.get();
              if (mThreshOrientation == 0) {
                mSensorReadings.putDouble("azimuth", mAzimuth);
                mSensorReadings.putDouble("pitch", mPitch);
                mSensorReadings.putDouble("roll", mRoll);
                if ((mSensorNumber == 1) && (System.currentTimeMillis() > (mDelayTime + mLastTime))) {
                  mLastTime = System.currentTimeMillis();
                  postEvent();
                }
              }
              if ((mThreshOrientation == 1) && (mSensorNumber == 1)) {
                if ((mXAxis == 1) && (mXCrossed == 0)) {
                  if (Math.abs(mAzimuth) > ((double) mThreshold)) {
                    mSensorReadings.putDouble("azimuth", mAzimuth);
                    postEvent();
                    mXCrossed = 1;
                  }
                }
                if ((mXAxis == 1) && (mXCrossed == 1)) {
                  if (Math.abs(mAzimuth) < ((double) mThreshold)) {
                    mSensorReadings.putDouble("azimuth", mAzimuth);
                    postEvent();
                    mXCrossed = 0;
                  }
                }
                if ((mYAxis == 2) && (mYCrossed == 0)) {
                  if (Math.abs(mPitch) > ((double) mThreshold)) {
                    mSensorReadings.putDouble("pitch", mPitch);
                    postEvent();
                    mYCrossed = 1;
                  }
                }
                if ((mYAxis == 2) && (mYCrossed == 1)) {
                  if (Math.abs(mPitch) < ((double) mThreshold)) {
                    mSensorReadings.putDouble("pitch", mPitch);
                    postEvent();
                    mYCrossed = 0;
                  }
                }
                if ((mZAxis == 4) && (mZCrossed == 0)) {
                  if (Math.abs(mRoll) > ((double) mThreshold)) {
                    mSensorReadings.putDouble("roll", mRoll);
                    postEvent();
                    mZCrossed = 1;
                  }
                }
                if ((mZAxis == 4) && (mZCrossed == 1)) {
                  if (Math.abs(mRoll) < ((double) mThreshold)) {
                    mSensorReadings.putDouble("roll", mRoll);
                    postEvent();
                    mZCrossed = 0;
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static class RollingAverage {
    private final int mmSampleSize;
    private final double mmData[];
    private int mmIndex = 0;
    private boolean mmFilled = false;
    private double mmSum = 0.0;

    public RollingAverage() {
      mmSampleSize = 5;
      mmData = new double[mmSampleSize];
    }

    public void add(double value) {
      mmSum -= mmData[mmIndex];
      mmData[mmIndex] = value;
      mmSum += mmData[mmIndex];
      ++mmIndex;
      mmIndex %= mmSampleSize;
      mmFilled = (!mmFilled) ? mmIndex == 0 : mmFilled;
    }

    public double get() throws IllegalStateException {
      if (!mmFilled && mmIndex == 0) {
        throw new IllegalStateException("No values to average.");
      }
      return (mmFilled) ? (mmSum / mmSampleSize) : (mmSum / mmIndex);
    }
  }
}