import { cloneDeep } from 'lodash'
import * as echarts from "echarts";
import { element } from 'protractor';

export const barChart_series: any[] = [
    {
        name: "",
        type: "bar",
        barGap: "50%",
        barCategoryGap: "30%",
        barMaxWidth: 11,
        data: [],
        label: {
            show: true,
            position: "right",
            fontSize: 11,
            fontWeight: "bold",
            color: "#333333",
        },
    },
];

const symbols = [
    "circle",
    "rect",
    "roundRect",
    "triangle",
    "diamond",
    "pin",
    "arrow",
];
export const getBasicLineChartSeries = function (
    datas: any[][],
    seryNames: any[],
    markLineData: { [key: string]: any }[][] = [],
    markAreaData: { [key: string]: any }[][][] = []
) {
    let series = [];
    for (let i = 0; i < seryNames.length; i++) {
        let sery = {
            name: seryNames[i],
            type: "line",
            symbol: symbols[i % symbols.length],
            symbolSize: 6,
            barGap: 0,
            smooth: 0.2,
            label: {
                show: true,
                position: "left",
                formatter: function (params) {
                    if (datas[i].length - 1 == params.dataIndex) {
                        return params.seriesName;
                    } else {
                        return "";
                    }
                },
            },
            data: datas[i],
            markLine: {
                symbol: 'none',
                label: {
                    position: 'insideEndTop'
                },
                data: [],
                tooltip: {
                    show: false
                }
            },
            markArea: {
                silent: true,
                itemStyle: {
                    borderWidth: 1,
                },
                data: []
            }
        };
        if (markLineData[i]) {
            sery.markLine.data = markLineData[i]
        }
        if (markAreaData[i]) {
            sery.markArea.data = markAreaData[i]
        }
        series.push(sery);
    }
    return series;
};
export const getBasicLineChartSeriesWithoutData = () => {
    return []
}

export const getMoreLineChartSeries = function (
    datas: any[][],
    seryNames: any[]
) {
    let series = [];
    for (let i = 0; i < seryNames.length; i++) {
        let sery = {
            name: seryNames[i],
            type: "line",
            symbol: symbols[i % symbols.length],
            symbolSize: 2,
            smooth: 0.2,
            lineStyle: {
                width: 1,
            },
            label: {
                show: false,
                fontWeight: "bold",
                color: "#000000",
            },
            data: datas[i],
        };
        series.push(sery);
    }
    return series;
};

export const getBigDataLineChartSeries = function (
    datas: any[][][],
    seriesNames: any[]
) {
    let series = [];
    for (let i = 0; i < seriesNames.length; i++) {
        let sery = {
            name: seriesNames[i],
            type: "line",
            symbol: symbols[i % symbols.length],
            symbolSize: 0.8,
            lineStyle: {
                width: 0.8,
            },
            data: datas[i],
        };
        series.push(sery);
    }
    return series;
};

export const getAnnotationsLineChartSeries = function (
    datas: any[][][],
    seriesNames: any[],
    markPoints: any[]
) {
    let series = [];
    for (let i = 0; i < seriesNames.length; i++) {
        let sery = {
            name: seriesNames[i],
            type: "line",
            symbol: symbols[i % symbols.length],
            symbolSize: 1.2,
            lineStyle: {
                width: 1.2,
            },
            // itemStyle: {
            //   shadowOffsetX: 2,
            //   shadowOffsetY: 2
            // },
            emphasis: {
                itemStyle: {
                    borderColor: "#ffffff",
                    borderWidth: 2,
                },
            },
            data: datas[i],
            areaStyle: {
                opacity: 0.5,
            },
            smooth: 0.8,
            markPoint: {
                data: markPoints[i],
                symbol: "circle",
                symbolSize: 8,
                label: {
                    show: true,
                    position: "right",
                    distance: 5,
                    color: "#000000",
                    formatter: function (param) {
                        return param.data.name;
                    },
                    backgroundColor: "#FFFFFF",
                    borderColor: "#7cb5ec",
                    borderWidth: 0.4,
                    padding: 5,
                    borderRadius: 2,
                },
                itemStyle: {
                    // color: "#020A0F",
                    borderColor: "#4D4D4D",
                    borderWidth: 0.5,
                },
            },
        };
        series.push(sery);
    }
    return series;
};

export const getNegativeBarChartSeries = function (datas: any[][][], seriesNames: any[], translationNumber: number) {
    let series = [];
    for (let i = 0; i < seriesNames.length; i++) {
        let sery = {
            name: seriesNames[i],
            type: "bar",
            // symbol: symbols[i % symbols.length],
            // symbolSize: 1.2,
            // lineStyle: {
            //   width: 1.2,
            // },
            // itemStyle: {
            //   shadowOffsetX: 2,
            //   shadowOffsetY: 2
            // },
            emphasis: {
                itemStyle: {
                    borderColor: "#ffffff",
                    borderWidth: 2,
                },
            },
            cursor: "pointer",
            barMaxWidth: 15,
            barGap: "35%",
            large: true,
            largeThreshold: 400,

            data: datas[i].map(element => {
                return [element[0], (+element[1] - translationNumber).toFixed(1)];
            }),
            // areaStyle: {
            //   opacity: 0.5,
            // },
            // smooth: 0.8,
            // markPoint: {
            //   data: markPoints[i],
            //   symbol: "circle",
            //   symbolSize: 8,
            //   label: {
            //     show: true,
            //     position: "right",
            //     distance: 5,
            //     color: "#000000",
            //     formatter: function (param) {
            //       return param.data.name;
            //     },
            //     backgroundColor: "#FFFFFF",
            //     borderColor: "#7cb5ec",
            //     borderWidth: 0.4,
            //     padding: 5,
            //     borderRadius: 2,
            //   },
            //   itemStyle: {
            //     // color: "#020A0F",
            //     borderColor: "#4D4D4D",
            //     borderWidth: 0.5,
            //   },
            // },
        };
        series.push(sery);
    }
    return series;
};
export const getNegativeBarChartSeriesDefault = function () {
    return [];
}
// 基础柱状图
export function getColumnChartSeries(style, data?) {
    if (!data) {
        return [];
    }
    const columnChartSeries = {
        name: '',
        type: 'bar',
        barGap: '10%',
        data: [],
        barMaxWidth: 30,
        label: {
            fontSize: style.fontSize - 1
        },
        markLine: {
            symbol: 'none',
            symbolSize: style.markLineSymbolSize,
            data: []
        },
    }
    let seriesArr = [];
    for (let i = 0; i < data.seriesName.length; i++) {
        let markLineArr = [];
        let columnSeries = cloneDeep(columnChartSeries);
        columnSeries.name = data.seriesName[i];

        columnSeries.data = data.yData[i]
        seriesArr.push(columnSeries)
        if (data.markLine[i]) {
            markLineArr = data.markLine[i]
        }
        columnSeries.markLine.data = markLineArr;
    }
    return seriesArr;
}
// 基础条形图（横向）
export function getBarChartSeries(style, data?) {
    if (!data) {
        return []
    }
    const barChartSeries = {
        name: '',
        type: 'bar',
        barGap: '50%',
        barCategoryGap: "30%",
        barMaxWidth: 10,
        data: [],
        label: {
            show: true,
            position: 'right',
            fontSize: style.fontSize - 1,
            fontWeight: 'bold',
            color: "#333333"
        }
    }
    let seriesArr = [];
    for (let i = 0; i < data.seriesName.length; i++) {
        let barSeries = cloneDeep(barChartSeries);
        barSeries.name = data.seriesName[i];
        barSeries.data = data.xData[i];
        seriesArr.push(barSeries)
    }
    return seriesArr;
}
// 分组堆叠柱状图
export function getStackBarChartSeries(data?) {
    if (!data) {
        return [];
    }
    const stackBarChartSeries = {
        name: '',
        type: 'bar',
        stack: '',
        barGap: '50%',
        barMaxWidth: 20,
        data: [],
    }
    let seriesArr = [];
    if (data.seriesName) {
        for (let i = 0; i < data.seriesName.length; i++) {
            let stackBarSeries = cloneDeep(stackBarChartSeries);
            stackBarSeries.name = data.seriesName[i];
            stackBarSeries.stack = data.stack[i];
            stackBarSeries.data = data.yData[i]
            seriesArr.push(stackBarSeries)
        }
    }
    return seriesArr;
}
// 金字塔图
export function getPyramidBarChartSeries(data?) {
    if (!data) {
        return [];
    }
    const pyramidBarChartSeries = {
        name: '',
        type: 'bar',
        stack: '',
        yAxisIndex: 0,
        barMaxWidth: 15,
        barCategoryGap: '50%',
        data: []
    }
    let pyramidSeries = []
    data.xData.forEach((item, index) => {
        let partOfSeries = cloneDeep(pyramidBarChartSeries);
        partOfSeries.name = data.seriesName[index];
        partOfSeries.stack = data.stack;
        partOfSeries.data = item;
        partOfSeries.yAxisIndex = index;
        pyramidSeries.push(partOfSeries);
    })
    return pyramidSeries
}
// 获取基础饼图系列配置（不含图例）
export function getBasicPieChartSeries(style, data: { name: string, value: string | number }[] = [], seriesName: string = 'seriesName') {
    const basicPieChartSeries = [{
        name: seriesName,
        type: 'pie',
        minAngle: 15,
        radius: '60%',
        center: ['50%', '50%'],
        selectedMode: 'single',
        selectedOffset: 20,
        data: data,
        label: {
            fontSize: style.fontSize - 1,
            formatter: '{b}: {d} %',

            alignTo: 'none',
            color: '#333333',
            fontWeight: 'bold',
        },
        labelLine: {
            smooth: true,
            length: 10,
            length2: 10
        },
        hoverOffset: 5,
        emphasis: {
            itemStyle: {
                shadowBlur: 5,
                shadowOffsetX: 0,
                shadowOffsety: 10,
            }
        }
    }]
    return basicPieChartSeries;
}
// 获取带图例饼图系列配置
export function getLegendPieChartSeries(style, data: { name: string, value: string | number }[] = [], seriesName: string = 'seriesName') {
    const legendPieChartSeries = [{
        name: seriesName,
        type: 'pie',
        minAngle: 15,
        radius: '60%',
        center: ['50%', '50%'],
        selectedMode: 'single',
        selectedOffset: 20,
        data: data,
        label: {
            show: false,
            fontSize: style.fontSize - 1,
            formatter: '{b}: {d} %',

            alignTo: 'none',
            color: '#333333',
            fontWeight: 'bold',
        },
        labelLine: {
            smooth: true,
            length: 10,
            length2: 10
        },
        hoverOffset: 5,
        emphasis: {
            itemStyle: {
                shadowBlur: 5,
                shadowOffsetX: 0,
                shadowOffsety: 10,
            }
        },
        animationDurationUpdate: 600
    }]
    return legendPieChartSeries;
}

// 获取玫瑰图饼图系列配置
export function getRosePieChartSeries(style, data: { name: string, value: string | number }[] = [], roseType: 'radius' | 'area' = 'radius', seriesName: string = 'seriesName') {
    const legendPieChartSeries = [{
        name: seriesName,
        type: 'pie',
        radius: ["20%", "50%"],
        center: ["50%", "50%"],
        roseType: roseType,
        selectedMode: 'single',
        selectedOffset: 20,
        data: data,
        label: {
            show: false,
            fontSize: style.fontSize - 1,
            formatter: '{b}: {d} %',

            alignTo: 'none',
            color: '#333333',
            fontWeight: 'bold',
        },
        labelLine: {
            smooth: true,
            length: 10,
            length2: 10
        },
        hoverOffset: 5,
        emphasis: {
            label: {
                show: true
            },
            itemStyle: {
                shadowBlur: 5,
                shadowOffsetX: 0,
                shadowOffsety: 10,
            }
        },
        animationDurationUpdate: 600
    }]
    return legendPieChartSeries;
}




//todo 声学分析系列配置
export function geSeriesOfNoiseAnalysisLine(data: any, colorMap) {
    let cubeData = []
    for (const item in colorMap) {
        cubeData.push({
            name: item,
            type: 'bar',
            itemStyle: {
                color: colorMap[item]
            },
            data: [],
            xAxisIndex: 1,
            yAxisIndex: 1
        })
    }
    if (data.rectsDataLists) {
        data.rectsDataLists = data.rectsDataLists.map((item) => {
            return {
                ...item,
                itemStyle: {
                    normal: {
                        color: colorMap[item.name]
                    }
                }
            }
        })
    }
    let renderItem = (params, api) => {
        var categoryIndex = api.value(0);
        var start = api.coord([api.value(1), categoryIndex]);
        var end = api.coord([api.value(2), categoryIndex]);
        var height = api.size([0, 1])[1] * 0.7;

        var rectShape = echarts.graphic.clipRectByRect({
            x: start[0],
            y: start[1] - height / 2,
            width: end[0] - start[0],
            height: height
        }, {
            x: params.coordSys.x,
            y: params.coordSys.y,
            width: params.coordSys.width,
            height: params.coordSys.height
        });

        return rectShape && {
            type: 'rect',
            shape: rectShape,
            style: api.style()
        };
    }
    let merdata: any = [{
        name: 'custom',
        type: 'custom',
        renderItem: renderItem,
        itemStyle: {
            opacity: 0.8
        },
        encode: {
            x: [1, 2],
            y: 0
        },
        data: data.rectsDataLists,
        xAxisIndex: 1,
        yAxisIndex: 1
    }]
    let seriesdata: any = [{
        name: 'brush',
        type: 'bar',
        data: data.xAxisDatas,
        yAxisIndex: 3,
        itemStyle: {
            opacity: 0
        }
    }]
    for (const item of data.monitorItem) {
        if (data.monitorItemDefaultShow.includes(item)) {
            seriesdata.push({
                name: item,
                type: 'line',
                symbol: 'circle',
                yAxisIndex: 0,
                itemStyle: {
                    normal: {
                        lineStyle: {
                            width: 1//设置线条粗细
                        }
                    }
                },
                data: data.yAxisDatas[item]
            })
        }
    }
    let finalseriesdata = merdata.concat(cubeData, seriesdata)
    return  finalseriesdata

}