package com.dinhcv.lifelogpedometer.activity;
  
  import android.app.DatePickerDialog;

  import android.app.ProgressDialog;

  import android.content.Context;
  import android.graphics.Color;
  import android.hardware.Sensor;
  import android.hardware.SensorEvent;
  import android.hardware.SensorEventListener;
  import android.hardware.SensorManager;
  import android.os.Bundle;
  import android.support.annotation.Nullable;
  import android.view.LayoutInflater;
  import android.view.Menu;
  import android.view.MenuInflater;
  import android.view.View;
  import android.view.ViewGroup;
  import android.widget.DatePicker;
  import android.widget.ImageView;
  import android.widget.LinearLayout;
  import android.widget.TextView;
  import android.widget.Toast;
  
  import com.dinhcv.lifelogpedometer.R;
  import com.dinhcv.lifelogpedometer.interfaces.LLAPIManagerListener;

  import com.dinhcv.lifelogpedometer.interfaces.StepListener;

  import com.dinhcv.lifelogpedometer.model.StepModel;
  import com.dinhcv.lifelogpedometer.model.structure.top.StepItemInfo;
  import com.dinhcv.lifelogpedometer.model.structure.top.TopInfo;

  import com.dinhcv.lifelogpedometer.portal.ApiServices;

  import com.dinhcv.lifelogpedometer.portal.LLAPIManager;
  import com.dinhcv.lifelogpedometer.utils.Const;
  import com.dinhcv.lifelogpedometer.utils.DayAxisValueFormatter;
  import com.dinhcv.lifelogpedometer.utils.Debug;

  import com.dinhcv.lifelogpedometer.utils.SimpleStepDetector;

  import com.dinhcv.lifelogpedometer.utils.Utils;
  import com.github.mikephil.charting.components.XAxis;
  import com.github.mikephil.charting.components.YAxis;
  
  import com.github.mikephil.charting.charts.BarChart;
  import com.github.mikephil.charting.data.BarData;
  import com.github.mikephil.charting.data.BarDataSet;
  import com.github.mikephil.charting.data.BarEntry;
  import com.github.mikephil.charting.interfaces.datasets.IBarDataSet;
  
  import org.eazegraph.lib.charts.PieChart;
  import org.eazegraph.lib.models.PieModel;
  import org.json.JSONArray;
  import org.json.JSONException;
  import org.json.JSONObject;
  
  import java.text.NumberFormat;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Calendar;
  import java.util.Date;
  import java.util.List;
  import java.util.Locale;
  
  import static com.github.mikephil.charting.utils.ColorTemplate.rgb;

  public class TopTodayFragment extends FragmentBase implements SettingFragmentPresenter, SensorEventListener, StepListener {

  
      private TextView stepsView;
      private TextView tvStepGoal;
      private TextView tvDistance;
      private TextView tvTime;
      private TextView tvStepRemain;
      private TextView tvStepRateDone;
      private boolean showSteps = true;
      private PieModel sliceGoal, sliceCurrent;
      private PieChart pg;
      private TextView tvDate;
      private ImageView ivBack;
      private ImageView ivNext;
  
      private LinearLayout llBike;
      private LinearLayout llWalking;
      private LinearLayout llRunning;
      private Const.STEP_TYPE stepType;
  
      private Date mAnaDate;
      private Calendar mCalendar;
  
      private int mAnaDay;
      private int mAnaMonth;
      private int mAnaYear;
  
      public static int STEP_SIZE = 75;
      private StepModel mStepModel;
      private TextView tvSmallStepGoal;
      private TextView tvSmallRemain;
      private Context mContext;
  
      public final static NumberFormat formatter = NumberFormat.getInstance(Locale.getDefault());
      private SensorManager sensorManager;
      private boolean activityRunning;
      private int stepTotal = 0;

      private int stepGoal = 0;

      private int stepCount = 0;
  
      private Date mFromDate;
      private Date mToDate;
  
      private TopInfo mTopInfo = new TopInfo();
      private BarChart mChart;
  
      private List<String> dateList;
      private String[] mParties;
      private Integer[] mStep;

      private ProgressDialog progress;

      private boolean isAccelo = false;
      private boolean isBusy = false;
      private SimpleStepDetector simpleStepDetector;

  
      private TopFragment mTopFragment;
      public void setRootFragment(TopFragment frag) {
          this.mTopFragment = frag;
      }
  
      @Override
      public void onCreate(final Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setHasOptionsMenu(true);

      }
  
      @Override
      public View onCreateView(final LayoutInflater inflater, final ViewGroup container,
                               final Bundle savedInstanceState) {
          final View v = inflater.inflate(R.layout.fragment_top_today, null);
          mContext = getActivity();
          sensorManager = (SensorManager) mContext.getSystemService(Context.SENSOR_SERVICE);

          simpleStepDetector = new SimpleStepDetector();
          simpleStepDetector.registerListener(this);

          initView(v);
  
          // slice for the steps taken today
          sliceCurrent = new PieModel("", 0, Color.parseColor("#6FE7F7"));
          pg.addPieSlice(sliceCurrent);
  
          // slice for the "missing" steps until reaching the goal
          sliceGoal = new PieModel("", Const.STEP_GOAL, Color.parseColor("#B7B8B6"));
          pg.addPieSlice(sliceGoal);

          pg.setDrawValueInPie(false);
          pg.setUsePieRotation(false);
          pg.startAnimation();
          pg.setAutoCenterInSlice(false);
  
          mCalendar = Calendar.getInstance();
          mCalendar.setTime(new Date());
          mAnaDate = mCalendar.getTime();
          mAnaYear = mCalendar.get(Calendar.YEAR);
          mAnaMonth = mCalendar.get(Calendar.MONTH);
          mAnaDay = mCalendar.get(Calendar.DAY_OF_MONTH);
  
          mFromDate = new Date();
  
          tvDate.setText(Utils.dateToStringFormatDayMonthYearJp(mAnaDate));
  
          initData();
  
          handleEvent();
  
          getTopPage(mAnaDate, stepType);
  
          return v;
      }
  
      private void initView(View v){
          stepsView = (TextView) v.findViewById(R.id.steps);
          tvDistance = (TextView) v.findViewById(R.id.tv_distance);
          tvStepGoal = (TextView) v.findViewById(R.id.tv_stepGoal);
          tvStepRemain = (TextView) v.findViewById(R.id.tv_stepRemain);
          tvStepRateDone = (TextView) v.findViewById(R.id.tv_stepRateDone);
          tvSmallStepGoal = (TextView) v.findViewById(R.id.tv_smallStepGoal);
          tvSmallRemain = (TextView) v.findViewById(R.id.tv_smallRemain);
          tvTime = (TextView) v.findViewById(R.id.tv_time);
          tvDate = (TextView) v.findViewById(R.id.tv_date);
          ivBack = (ImageView) v.findViewById(R.id.iv_back);
          ivNext = (ImageView) v.findViewById(R.id.iv_next);
  
          mChart = (BarChart) v.findViewById(R.id.chart);
          pg = (PieChart) v.findViewById(R.id.graph);
  
          llRunning = (LinearLayout) v.findViewById(R.id.ll_running);
          llWalking = (LinearLayout) v.findViewById(R.id.ll_walking);
          llBike = (LinearLayout) v.findViewById(R.id.ll_bike);
      }
  
      private void initData(){
          mCalendar = Calendar.getInstance();
          mCalendar.setTime(new Date());
          mAnaDate = mCalendar.getTime();
          mAnaYear = mCalendar.get(Calendar.YEAR);
          mAnaMonth = mCalendar.get(Calendar.MONTH);
          mAnaDay = mCalendar.get(Calendar.DAY_OF_MONTH);
  
  
          stepType = Const.STEP_TYPE.WALKING;
          updateUiStepType(false, true, false);
  
          tvDate.setText(Utils.dateToStringFormatDayMonthYearJp(mAnaDate));
      }
  
      private void updateUiStepType(boolean b1, boolean b2, boolean b3) {
          llBike.setSelected(b1);
          llWalking.setSelected(b2);
          llRunning.setSelected(b3);
      }
  
      private void stepsDistanceChanged() {

          if (progress != null){
              progress.dismiss();
          }

          updatePie();
          updateBars();
      }
  
  
      @Override
      public void onCreateOptionsMenu(final Menu menu, final MenuInflater inflater) {
          inflater.inflate(R.menu.main, menu);
      }
  
      private void getTopPage(Date date, Const.STEP_TYPE stepType){

          progress = new ProgressDialog(mContext);
          progress.setMessage(getString(R.string.loading));
          progress.setCancelable(false);
          progress.show();

          ApiServices.topInfo(date, stepType, new LLAPIManagerListener() {

              @Override
              public void onError(Error error) {
                  Debug.error("Get data history error");
                  hiddenDialog();
                  showDialogNotData();
              }
  
              @Override
              public void onSuccess(String json) {
                  Debug.error("Get data history success");

                  loadDataDone(json);
              }
  
              @Override
              public void onSuccess(JSONObject object) {
                  Debug.error("Get data history success");
                  hiddenDialog();
              }
          });
      }
  
      private void showDialogNotData(){
          showAlerDialog(mContext, getResources().getString(R.string.can_not_get_data));
      }
  
      private void loadDataDone(String jsonString) {
          JSONObject jsonObject = null;
          try {
              jsonObject = new JSONObject(jsonString);
              int status = jsonObject.optInt("status");
              if (status == 1) {
                  JSONObject jsonObject1 = jsonObject.optJSONObject("result");
                  JSONObject targetInf = jsonObject1.getJSONObject("targetInf");
  
                  if (targetInf != null){
                      String target = targetInf.optString("target_step");
                      Debug.normal("Target: "+ target);
                      mTopInfo.setTaget(targetInf.optString("target_step"));
                      mTopInfo.setSteps(targetInf.optString("num_step"));
                      mTopInfo.setStepRemain(targetInf.optString("remaining_step"));
                      mTopInfo.setCompletePercent(targetInf.optString("complete_percent"));
                  }
  
                  mTopInfo.setKcalo(jsonObject1.optString("kcal"));
                  mTopInfo.setDistance(jsonObject1.optString("distance"));
                  mTopInfo.setTime(jsonObject1.optString("time"));
                  JSONArray stepArr = jsonObject1.optJSONArray("dataChart");
  
  
                  if (stepArr != null && stepArr.length() > 0) {
                      List<StepItemInfo> infoLists = new ArrayList<>();
                      for (int i = 0; i < stepArr.length(); i++){
                          StepItemInfo stepItemInfo = new StepItemInfo();
                          JSONObject ob = (JSONObject) stepArr.get(i);
                          stepItemInfo.setHour(ob.optInt("hour"));
                          stepItemInfo.setNumStep(ob.optInt("numStep"));
                          infoLists.add(stepItemInfo);
                      }
  
                      mTopInfo.setStepList(infoLists);
                  }
  
              }
          } catch (JSONException e) {
              e.printStackTrace();
              mTopInfo = new TopInfo();;
          }
  
          stepsDistanceChanged();
      }
  
      private void updatePie() {
          // todayOffset might still be Integer.MIN_VALUE on first start
          int stepsToday = 0;
          int stepTarget = 0;
          if (mTopInfo != null) {

              if (mTopInfo.getSteps().contains(",")){
                  stepsToday = Integer.valueOf(mTopInfo.getSteps().replace(",", ""));
              }else {
                  stepsToday = Integer.valueOf(mTopInfo.getSteps());
              }

              if (mTopInfo.getTaget().contains(",")) {
                  stepTarget = Integer.valueOf(mTopInfo.getTaget().replace(",", ""));
              }else {
                  stepTarget = Integer.valueOf(mTopInfo.getTaget());
              }
          }
          sliceCurrent.setValue(stepsToday);
          if (stepTarget - stepsToday > 0) {
              // goal not reached yet
              if (pg.getData().size() == 1) {
                  pg.addPieSlice(sliceGoal);
              }
              sliceGoal.setValue(stepTarget - stepsToday);
          } else {
              // goal reached
              pg.clearChart();
              pg.addPieSlice(sliceCurrent);
          }
          pg.update();

          stepGoal = stepTarget;
          stepTotal = stepsToday;

          stepsView.setText(formatter.format(stepsToday));

          int stepRemain = stepTarget - stepsToday;
          tvStepRemain.setText(String.valueOf(stepRemain));
          tvStepRateDone.setText(getResources().getString(R.string.percent_unit, Utils.convert2String2Decimal(stepsToday *100/ stepTarget)));
          tvSmallRemain.setText(getResources().getString(R.string.pie_text_content3a, stepRemain));

          tvStepGoal.setText(mTopInfo.getTaget());
          tvSmallStepGoal.setText(mTopInfo.getTaget());

          tvDistance.setText(mTopInfo.getDistance());
          tvTime.setText(mTopInfo.getTime());
  
          double distanceToday = stepsToday * STEP_SIZE;
          distanceToday /= 100000;
          tvDistance.setText(Utils.convert2String2Decimal(distanceToday));
  
      }
  
      /**
       * Updates the bar graph to show the steps/distance of the last week. Should
       * be called when switching from step count to distance.
       */
      private void updateBars() {
  
          dateList = new ArrayList<>();
          List<String> dateList = new ArrayList<>();
          List<Integer> stepList = new ArrayList<>();
          List<StepItemInfo> stepItemInfos = mTopInfo.getStepList();
          if (stepItemInfos != null && stepItemInfos.size() >0) {
              for (int i = 0; i < stepItemInfos.size(); i++){
                  dateList.add(String.valueOf(stepItemInfos.get(i).getHour()));
                  stepList.add(stepItemInfos.get(i).getNumStep());
              }
          }
  
          mStep = stepList.toArray(new Integer[0]);
          mParties = dateList.toArray(new String[0]);
  
          initGraph();
      }
  
      private void initGraph(){
  
          mChart.setDrawBarShadow(false);
          mChart.setDrawValueAboveBar(true);
  
          // if more than 60 entries are displayed in the chart, no values will be
          // drawn
          mChart.setMaxVisibleValueCount(60);
  
          mChart.getDescription().setEnabled(false);
          // scaling can now only be done on x- and y-axis separately
          mChart.setPinchZoom(false);
  
          mChart.setDrawGridBackground(false);
          // mChart.setDrawYLabels(false);
          List<String> listx = Arrays.asList(mParties);
          DayAxisValueFormatter xValueFormatter = new DayAxisValueFormatter(listx);
  
          XAxis xAxis = mChart.getXAxis();
          xAxis.setLabelRotationAngle(0);
          xAxis.setPosition(XAxis.XAxisPosition.TOP);
          xAxis.setDrawGridLines(true);
          xAxis.setLabelCount(10);
          xAxis.setTextColor(Color.WHITE);
          xAxis.setValueFormatter(xValueFormatter);
  
  
          YAxis leftAxis = mChart.getAxisLeft();
          leftAxis.setDrawLabels(false);
          leftAxis.setDrawGridLines(false);
          leftAxis.setAxisMinimum(0f);
          leftAxis.setAxisMaximum(10000f);
          leftAxis.setDrawZeroLine(false);
  
          leftAxis.setEnabled(false);
          mChart.setDrawValueAboveBar(false);
          mChart.getAxisRight().setEnabled(false);
  
          // set auto scale min max
          mChart.setAutoScaleMinMaxEnabled(true);
          mChart.notifyDataSetChanged();
  
          // Set enimate y
          mChart.animateY(2000);
  
          setData();
  
          mChart.getLegend().setEnabled(false);
      }
  
  
      private void setData() {
  
          ArrayList<String> xVals = new ArrayList<>();
          for (int i = 0; i < mStep.length; i++) {
              xVals.add(mParties[i % mStep.length]);
          }
  
          ArrayList<BarEntry> yVals1 = new ArrayList<>();
          for (int i = 0; i < mStep.length; i++) {
              float val = (float) (mStep[i]*1);
              yVals1.add(new BarEntry(i, val));
          }
  
          BarDataSet set1;
  
          if (mChart.getData() != null && mChart.getData().getDataSetCount() > 0) {
              set1 = (BarDataSet)mChart.getData().getDataSetByIndex(0);
              set1.setValues(yVals1);
              mChart.getData().notifyDataChanged();
              mChart.notifyDataSetChanged();
          } else {
              ArrayList<Integer> colors = new ArrayList<>();
  
  
              int[] MATERIAL_COLORS = {rgb("#40CDEF")};
  
              for (int c : MATERIAL_COLORS)
                  colors.add(c);
  
              set1 = new BarDataSet(yVals1, null);
  
              set1.setColors(colors);
  
              ArrayList<IBarDataSet> dataSets = new ArrayList<>();
              dataSets.add(set1);
  
              BarData data = new BarData(dataSets);
              data.setValueTextSize(10f);
  
              mChart.setData(data);
          }
      }
  
  
  
      private void handleEvent(){
          tvDate.setOnClickListener(new View.OnClickListener() {
              @Override
              public void onClick(View view) {
                  handleAnaDatePicker();
              }
          });
  
          ivBack.setOnClickListener(new View.OnClickListener() {
              @Override
              public void onClick(View view) {
                  mCalendar = Calendar.getInstance();
                  mCalendar.setTime(mAnaDate);
                  mCalendar.add(Calendar.DAY_OF_MONTH, -1);
                  Date date = mCalendar.getTime();
                  tvDate.setText(Utils.dateToStringFormatDayMonthYearJp(date));
                  mAnaDate = date;

  
                  getTopPage(mAnaDate, stepType);

              }
          });
  
          ivNext.setOnClickListener(new View.OnClickListener() {
              @Override
              public void onClick(View view) {
                  mCalendar = Calendar.getInstance();
                  mCalendar.setTime(mAnaDate);
                  mCalendar.add(Calendar.DAY_OF_MONTH, +1);
                  Date date = mCalendar.getTime();
                  tvDate.setText(Utils.dateToStringFormatDayMonthYearJp(date));
                  mAnaDate = date;

  
                  getTopPage(mAnaDate, stepType);

              }
          });
  
          llBike.setOnClickListener(new View.OnClickListener() {
              @Override
              public void onClick(View view) {
                  stepType = Const.STEP_TYPE.BIKE;

                  updateUiStepType(true, false, false);

                  getTopPage(mAnaDate, stepType);
              }
          });
  
          llRunning.setOnClickListener(new View.OnClickListener() {
              @Override
              public void onClick(View view) {
                  stepType = Const.STEP_TYPE.RUNNING;
                  updateUiStepType(false, false, true);
                  getTopPage(mAnaDate, stepType);
              }
          });
  
          llWalking.setOnClickListener(new View.OnClickListener() {
              @Override
              public void onClick(View view) {
                  stepType = Const.STEP_TYPE.WALKING;

                  updateUiStepType(false, true, false);

                  getTopPage(mAnaDate, stepType);
              }
          });
  
  
      }
  
  
      /**
       * Show date picker dialog
       */
      private void handleAnaDatePicker() {
  
          new DatePickerDialog(getActivity(), new DatePickerDialog.OnDateSetListener() {
              @Override
              public void onDateSet(DatePicker view, int year, int monthOfYear, int dayOfMonth) {
  
                  mCalendar = Calendar.getInstance();
                  mCalendar.set(year, monthOfYear, dayOfMonth);
                  mAnaYear = year;
                  mAnaMonth = monthOfYear;
                  mAnaDay = dayOfMonth;
                  Date date = mCalendar.getTime();
                  tvDate.setText(Utils.dateToStringFormatDayMonthYearJp(date));
                  mAnaDate = date;
                  getTopPage(mAnaDate, stepType);
              }
          }, mAnaYear, mAnaMonth, mAnaDay).show();
  
      }
  
  
      private void updateUI(){

          creatLogStep();

          Debug.normal("Step total================ "+ stepTotal);
          int stepRemain  = stepGoal - stepTotal;
          double percentDone = stepTotal *100.0 / stepGoal;

          stepsView.setText(String.valueOf(stepTotal));
          tvStepRemain.setText(String.valueOf(stepRemain));
          tvStepRateDone.setText(getResources().getString(R.string.percent_unit, Utils.convert2String2Decimal(percentDone)));
          tvSmallRemain.setText(String.valueOf(stepRemain));
      }
  
      @Override
      public void onAttach(Context context) {
          super.onAttach(context);
  
      }
  
      @Override
      public void onSaveData() {
  
      }
  
      @Override
      public void onInvalidate(boolean isInit) {
          initData();
      }
  
      @Override
      public void onViewStateRestored(@Nullable Bundle savedInstanceState) {
          super.onViewStateRestored(savedInstanceState);
  
          initData();
      }
  
  
      @Override
      public void onResume() {
          super.onResume();
          activityRunning = true;

          Debug.normal("Today: "+ "Onresume ");

          Sensor countSensor = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER);

          if (countSensor == null) {
              isAccelo = true;
              countSensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);

          }

              if (countSensor != null) {
                  Debug.normal("Today: " + "countSensor not null ");
                  sensorManager.registerListener(this, countSensor, SensorManager.SENSOR_DELAY_UI);
              } else {
                  Debug.normal("Today: " + "countSensor is null ");
                  Toast.makeText(mContext, getResources().getString(R.string.sensor_available), Toast.LENGTH_SHORT).show();
              }

      }
  
      @Override
      public void onSensorChanged(SensorEvent event) {

          //Debug.normal("Sensor count step active");

          if (activityRunning){

              if (isAccelo) {
                  simpleStepDetector.updateAccel(
                          event.timestamp, event.values[0], event.values[1], event.values[2]);
              }else {
                  stepCount = (int) event.values[0];
                  Debug.normal("Step change: " + stepCount);
                  stepTotal++;
                  // update UI
                  updateUI();
              }

          }
      }
  
      @Override
      public void onAccuracyChanged(Sensor sensor, int accuracy) {
  
      }
  
      @Override
      public void onPause() {
          super.onPause();
          activityRunning = false;
          Debug.normal("Start create log");

          if (sensorManager != null) {
              sensorManager.unregisterListener(this);
          }

          // create log step

          //creatLogStep();

      }
  
      @Override
      public void onDestroy() {
          super.onDestroy();
      }
  
      private void creatLogStep(){

          Debug.normal("Today: "+ "Create log "+ stepCount);

          mToDate = new Date();

          ApiServices.createLog(stepType, stepCount, mFromDate, mToDate, new LLAPIManagerListener() {

              @Override
              public void onError(Error error) {

                  isBusy = false;

                  Debug.error("Get data history error");
              }
  
              @Override
              public void onSuccess(String json) {

                  isBusy = false;

                  Debug.error("Get data history success");
              }
  
              @Override
              public void onSuccess(JSONObject object) {

                  isBusy = false;

                  Debug.error("Get data history success");
              }
          });
      }

      @Override
      public void step(long timeNs) {
          if (!isBusy) {
              isBusy = true;
              stepCount = 1;
              stepTotal++;
              // update UI
              updateUI();
          }
      }

  }