package com.share.mvpsdk.utils;

import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.app.NotificationCompat;

import com.share.mvpsdk.view.chartview.data.Chart;
import com.share.mvpsdk.view.chartview.data.ChartPath;
import com.share.mvpsdk.view.chartview.data.DrawData;
import com.share.mvpsdk.view.chartview.data.InputData;

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

public class ValueUtils {

    public static float getCorrectedMaxValue(float maxValue) {
        for (float value = maxValue; value >= Chart.CHART_PART_VALUE; value--) {
            if (isRightValue(value)) {
                return value;
            }
        }

        return maxValue;
    }

    public static float max(@Nullable List<ChartPath> dataList) {
        float maxValue = 0;

        if (dataList == null || dataList.isEmpty()) {
            return maxValue;
        }
        for (ChartPath charpath :
                dataList) {
            for (InputData data : charpath.inputDataList) {
                if (data.valueY > maxValue) {
                    maxValue = data.valueY;
                }
            }
        }

        return maxValue;
    }

    private static long getMax(long max) {
        if (max < 10) {
            max = 10;
        } else if (max / 10 < 10) {
            max = (max / 10 + 1) * 10;
        } else if (max / 100 < 10) {
            max = (max / 100 + 1) * 100;
        } else if (max / 1000 < 10) {
            max = (max / 1000 + 1) * 1000;
        }
        return max;
    }

    private static float maxOne(List<InputData> dataList) {
        float maxValue = 0;

        if (dataList == null || dataList.isEmpty()) {
            return maxValue;
        }
        for (InputData data : dataList) {
            if (data.valueY > maxValue) {
                maxValue = data.valueY;
            }
        }

        return maxValue;
    }

    private static boolean isRightValue(float value) {
        float valueResidual = value % Chart.CHART_PART_VALUE;
        return valueResidual == 0;
    }

    @NotificationCompat.NotificationVisibility
    public static List<DrawData> getDrawData(@Nullable Chart chart) {
        if (chart == null || chart.getInputDataList()==null||chart.getInputDataList().isEmpty()) {
            return new ArrayList<>();
        }

        List<InputData> dataList = chart.getInputDataList();
//        correctDataListSize(dataList);//移除多余的数据
        return createDrawDataList(chart, createValueList(dataList));
    }

    @NotificationCompat.NotificationVisibility
    public static List<DrawData> getDrawDatas(@Nullable List<InputData> inputDataList, @NonNull Chart chart) {
        return createDrawDataList(chart, createValueList(inputDataList));
    }

//    private static void correctDataListSize(@NonNull List<InputData> dataList) {
//        if (dataList.size() < Chart.MAX_ITEMS_COUNT) {
//            addLackingItems(dataList);
//
//        } else if (dataList.size() > Chart.MAX_ITEMS_COUNT) {
//            removeExcessItems(dataList);
//        }
//    }
//
//    private static void addLackingItems(@NonNull List<InputData> dataList) {
//        for (int i = dataList.size(); i < Chart.MAX_ITEMS_COUNT; i++) {
//            long millis = dataList.get(0).valueX - TimeUnit.DAYS.toMillis(1);
//            if (millis < 0) {
//                millis = 0;
//            }
//
//            dataList.add(0, new InputData(0, millis));
//        }
//    }

    private static void removeExcessItems(@NonNull List<InputData> dataList) {
        for (ListIterator<InputData> iterator = dataList.listIterator(); iterator.hasNext(); ) {
            if (iterator.nextIndex() > Chart.MAX_ITEMS_COUNT) {
                iterator.remove();
                return;
            }
            iterator.next();
        }
    }

    public static float topValue = 0.00f;

    public static void calMax(List<ChartPath> chartPathList) {

        for (int i = 0; i < chartPathList.size(); i++) {
            createValueList(chartPathList.get(i).inputDataList);
        }
    }

    private static List<Float> createValueList(@NonNull List<InputData> dataList) {
        List<Float> valueList = new ArrayList<>();
        topValue = topValue > ValueUtils.maxOne(dataList) ? topValue : ValueUtils.maxOne(dataList);//取最大值

        for (InputData data : dataList) {
            float value = data.valueY / topValue;
            valueList.add(value);
        }

        return valueList;
    }

    @NonNull
    private static List<DrawData> createDrawDataList(@NonNull Chart chart, @NonNull List<Float> valueList) {
        List<DrawData> drawDataList = new ArrayList<>();
        for (int i = 0; i < valueList.size() - 1; i++) {
            DrawData drawData = createDrawData(chart, valueList, i);
            drawDataList.add(drawData);
        }
        return drawDataList;
    }

    @NonNull
    private static DrawData createDrawData(@NonNull Chart chart, @NonNull List<Float> valueList, int position) {
        DrawData drawData = new DrawData();
        if (position > valueList.size() - 1) {
            return drawData;
        }

        float value = valueList.get(position);
        float startX = getCoordinateX(chart, position);
        float startY = getCoordinateY(chart, value);
        drawData.startX = startX;
        drawData.startY = startY;
//		drawData.setStartX(startX);
//		drawData.setStartY(startY);
        int nextPosition = position + 1;
        if (nextPosition < valueList.size()) {
            float nextValue = valueList.get(nextPosition);
            float stopX = getCoordinateX(chart, nextPosition);
            float stopY = getCoordinateY(chart, nextValue);

//			drawData.setStopX(stopX);
//			drawData.setStopY(stopY);

            drawData.stopX = stopX;
            drawData.stopY = stopY;
        }

        return drawData;
    }

    @SuppressWarnings("UnnecessaryLocalVariable")
    private static float getCoordinateX(@NonNull Chart chart, int index) {
        float width = chart.width;
        float titleWidth = chart.titleWidth;

        float widthCorrected = width - titleWidth;
        float partWidth = widthCorrected / (Chart.MAX_ITEMS_COUNT - 1);
        float coordinate = titleWidth + (partWidth * index);

        if (coordinate < 0) {
            coordinate = 0;

        } else if (coordinate > width) {
            coordinate = width;
        }

        return coordinate;
    }

    @SuppressWarnings("UnnecessaryLocalVariable")
    private static float getCoordinateY(@NonNull Chart chart, float value) {
        float height = chart.height - chart.padding - chart.textSize;
        float heightOffset = chart.heightOffset;
        float heightCorrected = height - heightOffset;
        float coordinate = (heightCorrected - (heightCorrected * value));
        if (coordinate < 0) {
            coordinate = 0;

        } else if (coordinate > heightCorrected) {
            coordinate = heightCorrected;
        }

        coordinate += heightOffset;
        return coordinate;
    }

}