package meritech.sigma.ui.chart;

import android.content.Context;
import android.support.v7.widget.CardView;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.RelativeLayout;
import android.widget.TableLayout;
import android.widget.TextView;

import com.scichart.charting.model.RenderableSeriesCollection;
import com.scichart.charting.model.dataSeries.XyDataSeries;
import com.scichart.charting.visuals.renderableSeries.FastLineRenderableSeries;
import com.scichart.core.framework.UpdateSuspender;
import com.scichart.core.model.DateValues;
import com.scichart.core.model.DoubleValues;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
import java.util.Enumeration;

import meritech.sigma.R;
import meritech.sigma.model.CurrentTestState;
import meritech.sigma.model.LegendItem;
import meritech.sigma.model.LicenseManager;
import meritech.sigma.model.LinePatternType;
import meritech.sigma.service.MeritechService;
import meritech.sigma.service.qualcomm.LTECellInfo;
import meritech.sigma.service.qualcomm.LTEFilterData;
import meritech.sigma.service.qualcomm.LTEFilterDataHistory;
import meritech.sigma.service.qualcomm.QualcommDataService;
import meritech.sigma.service.rssi.PhoneStateTrackerService;
import meritech.sigma.util.Constants;
import meritech.sigma.util.NumberFormatter;
import meritech.sigma.util.android.SigmaLog;

// Modified and documented By Dinesh Kumar Aug 2018
public class RSRPChart extends BaseQualcomChartCard{

    public static final String ACTION_NAME = "meritech.sigma.ui.chart.RSRPChart";
    private static final int MAXIMUM_Y_VALUE = 0;
    private static final int MINIMUM_Y_VALUE = -150;
    private static final int MAX_MONITOR_SET = 3;
    private static final String TITLE = "RSRP CHART";

    private final Map<String, Integer> _colorRsrpHM = new HashMap<>();

    private TextView _textViewServingCellRsrp;
    private TextView _textViewServingCellRsrpScell1;
    private TextView _textViewServingCellRsrpScell2;
    private TextView _textViewServingCellRsrpScell3;

    public RSRPChart(Context context, AttributeSet attrs) {
        super(context, attrs, TITLE);
//		updateViews();

    }

    public RSRPChart(Context context, boolean isVisible) {
        super(context, TITLE, isVisible);
//		updateViews();
    }

    @Override
    public void setTitle(String title) {

    }

    @Override
    public void setFontSize(int fontSize) { //setting Range and Domain Label text size
    }

    @Override
    protected void init(Context context) {
        final LayoutInflater inflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        View v = inflater.inflate(R.layout.control_rsrp_chart, this);

        _textViewServingCellRsrp = v.findViewById(R.id.textviewRsRpPcell);
        _textViewServingCellRsrpScell1 = v.findViewById(R.id.textviewRsRpScell);
        _textViewServingCellRsrpScell2 = v.findViewById(R.id.textviewRsRpScell2);
        _textViewServingCellRsrpScell3 = v.findViewById(R.id.textviewRsRpScell3);

        table = v.findViewById(R.id.table1);
        _relativeLayoutHeader = v.findViewById(R.id.layoutHeader);
        cardviewMain = v.findViewById(R.id.cardMain);
        buildChart();
    }


    @Override
    public void updateViews(MeritechService dataService) {
        if (dataService != null && isCardVisible()) {
            try {
//				if (((MainActivity) getContext()).isAnyTestRelatedServicesRunning()) {
                if (LicenseManager.isL01OptionEnabled() && CurrentTestState.isPhoneQualcommSupported() // For Qualcomm //dinesh
                        && (dataService instanceof QualcommDataService)) {
                    QualcommDataService _dataService = (QualcommDataService) dataService;
                    //  setHistory123456(_dataService.getLTEHistory());
                    setHistoryInSciChart(_dataService.getLTEHistory());
                    if (_dataService.isCurrentCellSearchNetworkTypeLTE()) {
                        if (LicenseManager.isCAOptionEnabled()) {
                            updateRsrpValues(_dataService.getLastLTEFilterData());
                        }
                    }
                } else if (dataService instanceof PhoneStateTrackerService) { // For Phone //dinesh
                    PhoneStateTrackerService _phoneStateTrackerService = (PhoneStateTrackerService) dataService;
                    //   setHistory123456(_phoneStateTrackerService.getLTEHistory());
                    setHistoryInSciChart(_phoneStateTrackerService.getLTEHistory());
                    if (_phoneStateTrackerService.isCurrentCellSearchNetworkTypeLTE()) {
                        final int nwTypeCode = _phoneStateTrackerService.getLastNetworkTypeCode();
                        if (nwTypeCode == 13) {
                            updateRsrpValues(_phoneStateTrackerService.getLastLTEFilterData());
                        }
                    }
                }
//				}
            } catch (Exception ex) {
                SigmaLog.e("RsRpChartFragment::updateViews() exception: " + ex);
            }
        }
    }

    private void updateRsrpValues(final LTEFilterData data) {
            for (final LTECellInfo info : data.cellInfoList) {

                if (info.type.equalsIgnoreCase(Constants.LTE_PCELL)) {
                    if (info.rsrp != -999.0) {
                        setServingCellRsrpValue(NumberFormatter.oneDecimal(getResources(), info.rsrp));
                    } else {
                        setServingCellRsrpValue(getResources().getString(R.string.unknownValue));
                    }
                } else if (info.type.equalsIgnoreCase(Constants.LTE_SCELL1)) {
                    if (info.rsrq != -999.0) {
                        setServingCellRsrpScell1Value(NumberFormatter.oneDecimal(getResources(), info.rsrp));
                    } else {
                        setServingCellRsrpScell1Value(getResources().getString(R.string.unknownValue));
                    }
                } else if (info.type.equalsIgnoreCase(Constants.LTE_SCELL2)) {
                    if (info.rsrq != -999.0) {
                        setServingCellRsrpScell2Value(NumberFormatter.oneDecimal(getResources(), info.rsrp));
                    } else {
                        setServingCellRsrpScell2Value(getResources().getString(R.string.unknownValue));
                    }
                } else if (info.type.equalsIgnoreCase(Constants.LTE_SCELL3)) {
                    if (info.rsrq != -999.0) {
                        setServingCellRsrpScell3Value(NumberFormatter.oneDecimal(getResources(), info.rsrp));
                    } else {
                        setServingCellRsrpScell3Value(getResources().getString(R.string.unknownValue));
                    }
                }
        }
    }

    @Override
    public String getKey() {
        // TODO Auto-generated method stub
        return ACTION_NAME;
    }

    @Override
    protected void sendToCustomView(Context context) {
        saveCustomViewCardsToPersistence(context);

    }

    private void setServingCellRsrpValue(CharSequence servingCellRsrpValue) {
        _textViewServingCellRsrp.setText(servingCellRsrpValue);
    }

    private void setServingCellRsrpScell1Value(CharSequence servingCellRsrpScell) {
        _textViewServingCellRsrpScell1.setText(servingCellRsrpScell);
    }

    private void setServingCellRsrpScell2Value(CharSequence servingCellRsrpScell) {
        _textViewServingCellRsrpScell2.setText(servingCellRsrpScell);
    }

    private void setServingCellRsrpScell3Value(CharSequence servingCellRsrpScell) {
        _textViewServingCellRsrpScell3.setText(servingCellRsrpScell);
    }

    //-----------------------------------------------SCI_CHART-------------------------------------------------

    private final Hashtable<String, XyDataSeries<Date, Double>> currentRsrpSeriesHT = new Hashtable<>();
    private Hashtable<String,FastLineRenderableSeries> fastlineHT = new Hashtable<>();

    /**Configuring sci-chart*/
    protected void buildChart() {
        super.buildChart();
        setXAxis(getContext().getText(R.string.time).toString());
        setYAxis(getContext().getText(R.string.rsrpdBm).toString());
        addLegend();
        hideBackgroundLines();
    }

    private void setHistoryInSciChart(final LTEFilterDataHistory history) {
        if (history.size() == 0) {
            return;
        }
        UpdateSuspender.using(chartSurface, new Runnable() {
            @Override
            public void run() {
                clearDataForChart();//Clearing old data from chart

                double rsrp;
                int scrCode;

                double max = MINIMUM_Y_VALUE;
                double min = MAXIMUM_Y_VALUE;

                for (int index = 0; index < history.size(); index++) {

                    final LTEFilterData reading = history.get(index);
                    final int scramblingCodeCount = reading.cellInfoList.size();
                    int countMonitorSet = 0;

                    for (int scIndex = 0; scIndex < scramblingCodeCount; scIndex++) {
                        // check invalid data like -999
                        rsrp = reading.cellInfoList.get(scIndex).rsrp;
                        scrCode = reading.cellInfoList.get(scIndex).pci;
                        String _currentsettype = reading.cellInfoList.get(scIndex).type;
                        long domainValue = reading.timeStamp + CurrentTestState.getCurrentQcommTimeShift();

                        if ((Double.isNaN(rsrp)) || (rsrp == -999.0) || (scrCode == -999.0)) {
                            continue;
                        }

                        if (reading.cellInfoList.get(scIndex).type.equals(Constants.LTE_PCELL)) { // if it is PCell
                            addDataToXyDataSeries(domainValue, rsrp, Integer.toString(scrCode) + "_P", scrCode);
                        } else if (reading.cellInfoList.get(scIndex).type.equals(Constants.LTE_SCELL1)) {
                            addDataToXyDataSeries(domainValue, rsrp, Integer.toString(scrCode) + "_S1", scrCode);
                        } else if (reading.cellInfoList.get(scIndex).type.equals(Constants.LTE_NBR) && countMonitorSet < MAX_MONITOR_SET) {
                            addDataToXyDataSeries(domainValue, rsrp, Integer.toString(scrCode) + "_N", scrCode);
                            countMonitorSet++;
                        } else {
                            continue;
                        }

                        storeColorForLines(scrCode); //   // Storing color values according to pci values ` in HashMap

                        if (history.size() == 1) {
                            //   addDataToDataSeries(currentSeries, 0, 0);
                        }

                        if (!Double.isNaN(rsrp)) { //if it is a number.. add it in _current series
                            //  long domainValue = reading.timeStamp + CurrentTestState.getCurrentQcommTimeShift();
                            // double rangeValue = rsrp;
                            // addDataToDataSeries(currentSeries, domainValue, rangeValue);
                            if (max < rsrp) {
                                max = rsrp;
                            }
                            if (min > rsrp) {
                                min = rsrp;
                            }
                        }
                    }
                }


                addRenderSeriesToChart();//plotting currentSeries at Chart
                setVisibleRange(min, max);

            }
        });
    }

    /** Add all renderable series on chart*/
    private void addRenderSeriesToChart() {
        Enumeration<String> keys = currentRsrpSeriesHT.keys();

        while (keys.hasMoreElements()) {
            final String sc = keys.nextElement();
            XyDataSeries<Date, Double> dataSeries = currentRsrpSeriesHT.get(sc);
            FastLineRenderableSeries lineSeries = getFastLineRenderSeries(sc);

            lineSeries.setDataSeries(dataSeries);

            if(!chartSurface.getRenderableSeries().contains(lineSeries)){
                chartSurface.getRenderableSeries().add(lineSeries);
            }

        }

        chartSurface.zoomExtents();

    }

    /**add data to either new XyDataSeries or already stored in Hashtable */
    private void addDataToXyDataSeries(long domainValue, double rsrp, String seriesNam, int scrCode) {
        XyDataSeries<Date, Double> xySeries = currentRsrpSeriesHT.get(Integer.toString(scrCode));

        if (xySeries == null) {
            xySeries = new XyDataSeries<>(Date.class, Double.class);
            currentRsrpSeriesHT.put(Integer.toString(scrCode), xySeries);
        }

        DateValues domVal = new DateValues();
        DoubleValues rangeVal = new DoubleValues();
        domVal.addTime(domainValue);
        rangeVal.add(rsrp);
        xySeries.append(domVal, rangeVal);
        xySeries.setSeriesName(seriesNam);

    }

    /** provide FastLineRenderableSeries either new or from hashtable */
    private FastLineRenderableSeries getFastLineRenderSeries(String scr) {
        FastLineRenderableSeries fastLineRenderableSeries = fastlineHT.get(scr);

        if(fastLineRenderableSeries == null){
            String colorKey = _colorRsrpHM.get(scr).toString();
            fastLineRenderableSeries = super.getFastLineRenderSeries(Integer.parseInt(colorKey));
            fastlineHT.put(scr,fastLineRenderableSeries);
        }
        return fastLineRenderableSeries;
    }

    /** Clear previous data from chart*/
    private void clearDataForChart() {
        RenderableSeriesCollection renderableSeriesCollection = chartSurface.getRenderableSeries();
        int size = renderableSeriesCollection.size() - 1;
        for (int i = size; i >= 0; i--) {
            if (!renderableSeriesCollection.isEmpty()) {
                FastLineRenderableSeries renderableSeries = (FastLineRenderableSeries)renderableSeriesCollection.get(i);
                if(renderableSeries != null){
                    renderableSeries.getDataSeries().clear();
                }
            }
        }
        currentRsrpSeriesHT.clear();

        Enumeration<String> keyCol = fastlineHT.keys();

        while(keyCol.hasMoreElements()){
            String sc = keyCol.nextElement();
            FastLineRenderableSeries fSeries = fastlineHT.get(sc);
            if(fSeries!=null ){
                // if(!fSeries.getIsSelected()) {
                chartSurface.getRenderableSeries().remove(fSeries);
                fastlineHT.remove(fSeries);
            }
        }

    }

    /**store each lines unique color in hashtable*/
    private void storeColorForLines(int scrCode) {
        if (!_colorRsrpHM.containsKey(Integer.toString(scrCode))) {
            int scrColor = getRandomColor(scrCode);
            _colorRsrpHM.put(Integer.toString(scrCode), scrColor);
        }
    }

}