const chartDataTransform = {
    /**
     * rowdata를 사용자 선택에 맞게 반환
     * @param rowdata : 원본 데이터
     * @param x : x축 객체 데이터
     * @param yArr : y축 배열 데이터
     */
    createData: function(rowdata, xAxisList, yAxisList, group){
        let resultArr = [];
        let x;
        //x축 객체 배열 데이터를 가져와서 columnNm 값을 가져옴
        if(xAxisList.length !== 0){
            x = xAxisList[0].columnIdx;
        }

        //y축 객체 배열 데이터를 가져와서 columnNm 값을 배열로 가져옴
        let yArr = yAxisList.map(field => {
            return {
                valNm: field.columnNm,
                valIndex: field.columnIdx
            }
        });

        if (yArr.length > 0) {
            // 반복문을 통해 y축의 데이터를 가져와서 datalist에 추가
            for(let i = 0; i < rowdata.length; i++) {
                let data = {
                    categoryData: rowdata[i][x]
                }
                // data에 y축의 다중데이터 추가
                yArr.forEach(field => {
                    const fieldName = field.valNm;
                    if(!data[fieldName]) {
                        data[fieldName] = 0;
                    }
                    data[fieldName] += Number(rowdata[i][field.valIndex]);
                });
                // group 추가
                if(group !== undefined && group !== ""){
                data.group = rowdata[i][group];}
                resultArr.push(data);
            }
        }
        return resultArr;

    },
    /**
     * 변환된 데이터 그룹화
     * @param data : 변환된 데이터
     * @param yArr : y축 카테고리 배열 데이터
     */
    dataGrouping: function(data, yArr){
        if (!Array.isArray(data) || !data) {
            return {};
        }
        return data.reduce((acc, cur) => {
            if (!acc[cur.categoryData]) {
                acc[cur.categoryData] = {};
                // 각 필드 초기화
                yArr.forEach(field => {
                    acc[cur.categoryData][field.valNm] = { values: [], sum: 0, min: Infinity, max: -Infinity, count: 0 };
                });
            }

            // 각 필드별 합계 계산
            yArr.forEach(field => {
                const fieldName = field.valNm;
                // cur[fieldName]이 배열인지 확인하고, 아니라면 배열로 만듦
                let values = Array.isArray(cur[fieldName]) ? cur[fieldName] : [cur[fieldName]];
                values.forEach(value => {
                    acc[cur.categoryData][fieldName].values.push(value);
                    acc[cur.categoryData][fieldName].sum += value;
                    acc[cur.categoryData][fieldName].min = Math.min(acc[cur.categoryData][fieldName].min, value);
                    acc[cur.categoryData][fieldName].max = Math.max(acc[cur.categoryData][fieldName].max, value);
                    acc[cur.categoryData][fieldName].count += 1;
                });
            });

            return acc;
        }, {});
    },

    /**
     * 데이터 계산 값으로 가공 (min, max, sum, avg)
     * @param groupData : 그룹화된 데이터
     * @param selectedCal : 사용자가 선택한 계산 값
     */
    calculateSetting: function(groupData, selectedCal) {
        let result = Object.keys(groupData).map(categoryData => {
            const result = { categoryData: categoryData };
            Object.keys(groupData[categoryData]).forEach(fieldName => {
                const fieldData = groupData[categoryData][fieldName];
                switch (selectedCal) {
                    case "sum":
                        result[fieldName] = fieldData.sum;
                        break;
                    case "avg":
                        result[fieldName] = fieldData.sum / fieldData.count;
                        break;
                    case "min":
                        result[fieldName] = fieldData.min;
                        break;
                    case "max":
                        result[fieldName] = fieldData.max;
                        break;
                }
            });
            return result;
        });
        return result;
    },

    /**
     * 데이터 필터링
     * 선택 된 그룹의 데이터로 가공
     */
    setFilteringData : function(dataList ,subGroupArr, selectedSubGroup){
        // groupSubArr에서 selectedSubGroup의 index를 찾아서 그 columnNm을 찾아옴
        const selectedSubGroupNm = subGroupArr.find(column => column.index === Number(selectedSubGroup)).columnNm;
        return dataList.filter(data => data.group === selectedSubGroupNm);
    },
    /**
     * 음수 차트 데이터 처리
     */
    convertValuesToNegative: function(data, fieldNm){
        // 데이터 리스트를 순회하며 각 객체의 값을 확인
        let test = data.forEach(obj => {
            obj[fieldNm] = -Math.abs(obj[fieldNm]);
        });
        return test;
    },
    
}

export default chartDataTransform;