import { assetManager, js, TextAsset } from "cc";
import { EBundleName } from "../const/GameEnum";
import { ObjectArray } from "../const/GameInterface";
import ResLoad from "../ResUrl/ResLoad";
import { ICsvData } from "./CsvList";
import { run } from "node:test";
import { PREVIEW } from "cc/env";


export default class CSVTools {

    public static CSVToArray(strData, strDelimiter) {
        strDelimiter = (strDelimiter || ",");
        var objPattern = new RegExp(
            (
                "(\\" + strDelimiter + "|\\r?\\n|\\r|^)" +
                "(?:\"([^\"]*(?:\"\"[^\"]*)*)\"|" +
                "([^\"\\" + strDelimiter + "\\r\\n]*))"
            ),
            "gi"
        );
        var arrData = [[]];
        var arrMatches = null;
        while (arrMatches = objPattern.exec(strData)) {
            var strMatchedDelimiter = arrMatches[1];
            if (
                strMatchedDelimiter.length &&
                (strMatchedDelimiter != strDelimiter)
            ) {
                arrData.push([]);
            }
            if (arrMatches[2]) {
                var strMatchedValue = arrMatches[2].replace(
                    new RegExp("\"\"", "g"),
                    "\""
                );
            } else {
                var strMatchedValue = arrMatches[3];
            }
            arrData[arrData.length - 1].push(strMatchedValue);
        }
        return arrData;
    }
    public static async LoadCsv(url: string, onCompleted: Function, cnf: ICsvData) {
        ResLoad.Ins.Load(url, EBundleName.Presets, TextAsset, (err, res: TextAsset) => {
            if (err || !res) {
                ConsoleEx.Error("加载失败", url, res, err);
                return;
            }
            onCompleted && onCompleted(this.parse(res.text, cnf), res.name);
            assetManager.releaseAsset(res)
        });
    }

    public static LoadCsvByText(text: string, onCompleted: Function, cnf: ICsvData) {
        onCompleted(this.parse(text, cnf), cnf.name);
    }


    public static parse(csv_txt: string, cnf: ICsvData, _: string = ',') {

        let type = cnf.type;
        let txt_array = this.CSVToArray(csv_txt, _);
        let keys = txt_array[0];
        let types = txt_array[2]
        let params = type == 'object' ? {} : [];
        for (let i = 3; i < txt_array.length; i++) {
            let b = { id: parseInt(txt_array[i][0]) };
            for (let k = 1; k < keys.length; k++) {
                if (types[k] == 'int') {
                    b[keys[k]] = Number(txt_array[i][k]);
                } else if (types[k] == 'array') {
                    b[keys[k]] = this.isParseArray(txt_array[i][k], keys[k], i)
                } else if (types[k] == 'strArray') {
                    b[keys[k]] = this.isParseStrArray(txt_array[i][k], keys[k])
                } else if (types[k] == 'objectArray') {
                    b[keys[k]] = this.isParseObjectArray(txt_array[i][k], keys[k])
                } else if (types[k] == 'object') {
                    b[keys[k]] = this.isParseObject(txt_array[i][k], keys[k])
                } else if (types[k] == 'comobject') {
                    b[keys[k]] = this.isParaseComObject(txt_array[i][k], keys[k])
                } else {
                    b[keys[k]] = txt_array[i][k];
                }
            }

            if (type == 'object') {
                params[txt_array[i][1]] = b
            } else {
                params['push'](b);
            }
        }
        return this.check(params, cnf);
    }

    /** 整理数据 */
    private static check(json, data: ICsvData) {
        if (!data.check) {
            return json;
        }
        let params = {};
        let checks = data.check;
        if (Array.isArray(checks)) {
            for (let i = 0; i < checks.length; i++) {
                if (i == 0) {
                    params = this.checkData(json, checks[i]);
                } else {

                    if (data.type2 || data.type3) {

                        for (let item in params) {
                            let t_params = {};
                            let array = params[item];
                            for (let j = 0; j < array.length; j++) {
                                let lv = array[j][checks[i]];
                                if (data.type2) {
                                    lv -= 1;
                                }
                                t_params[lv] = array[j];
                            }
                            params[item] = t_params;
                        }

                    } else {

                        for (let item in params) {
                            params[item] = this.checkData(params[item], checks[i]);
                        }

                    }

                }
            }
        } else if (js.isString(checks)) {
            for (let key in json) {
                let stype = json[key] ? json[key][checks] : null;
                params[stype] = json[key];
            }
        }
        return params;
    }

    /** 整理数据 */
    private static checkData(param, check) {
        let params = {};
        try {
            for (let key in param) {
                let stype = param[key][check]
                if (!params[stype]) {
                    params[stype] = [];
                }
                params[stype].push(param[key]);
            }
            return params;
        } catch {
            ConsoleEx.Error('解析失败: ' + param + "       " + check)
            return params;
        }

    }


    /*** 解析object */
    public static isParseObject(value, key) {
        try {
            let object = {};
            if (value.length == 0) {
                return object;
            }

            if (value.length == 2) {
                return object;
            }
            let str = value.substring(1, value.length - 1);
            let array = str.split(',');
            for (let o = 0; o < array.length; o++) {
                let oarray = array[o].split(':');
                object[oarray[0]] = Number(oarray[1])
            }
            return object;
        } catch (e) {
            ConsoleEx.Error('解析失败: ' + key + "       " + value)
            return null;
        }
    }

    /** 解析字符数组 */
    public static isParseStrArray(value, key) {
        try {
            let strArray = [];
            let str: string = value.substring(1, value.length - 1);
            let array = str.split(',');
            while (array[0] == "") {
                array.shift();
            }
            strArray = array
            return strArray;
        } catch (e) {
            ConsoleEx.Error('解析失败: ' + key + "       " + value)
            return null;
        }
    }

    /** 解析数组 */
    public static isParseArray(value: string, key, idx: number) {
        value = value.replace(new RegExp("\n", "g"), "")
        if (!value || value.length == 0) { return []; }
        try {
            return JSON.parse(value);
        } catch (e) {
            ConsoleEx.Error('解析失败: ' + key + "   " + "第" + (idx + 1) + "行" + "       " + value)
            return [];
        }
    }

    /** 解析数组对象 */
    public static isParseObjectArray(value, key) {
        let datas: ObjectArray = [];
        if (value.length <= 2) {
            return datas;
        }
        let str = value.substring(1, value.length - 1);
        let array = str.split(',');
        for (let o = 0; o < array.length; o++) {
            let oarray = array[o].split(':');
            oarray.length != 2 && ConsoleEx.Error('解析数组对象失败: ' + value + '  key: ' + key);
            datas.push({ key: Number(oarray[0]), value: Number(oarray[1]) })
        }
        return datas;
    }
    /** 解析复合类型 */
    public static isParaseComObject(value, key) {
        if (value == undefined) {
            return [];
        }
        let str = value.substring(1, value.length - 1);
        let object = str.split(',');
        let param = [];
        for (let i = 0; i < object.length; i++) {
            let ps = object[i].split(':')
            if (ps.length == 2) {
                param.push({ type: Number(ps[0]), id: Number(ps[1]), num: Number(ps[1]) })
            } else if (ps.length == 3) {
                param.push({ type: Number(ps[0]), id: Number(ps[1]), num: Number(ps[2]) })
            } else {

            }
        }
        return param;
    }

    /** 解析复合类型 */
    public static isParaseComObjectToJson(value) {
        if (typeof value == "string") {
        } else {
            value = `${value}`
        }
        return JSON.stringify(CSVTools.isParaseComObject(value, 0));
    }

}

if (PREVIEW) {
    window["isParaseComObjectToJson"] = CSVTools.isParaseComObjectToJson;
}