import {
    RDSDataService,
} from "aws-sdk";
import { QueryBuilderBaseParamEnum } from "../enums";
import { LeQuerybuilderAuroraMysqlDataApiError, LeQuerybuilderAuroraMysqlDataApiErrorEnum } from "../error";
import {
    KeyValueJson,
    QueryBuilderConfBatchField,
    QueryBuilderField,
} from "../interfaces";
import { classLikeFormation } from "../utils";
import { formatJoinableTables, JoinableTable } from "./join-query";

export interface QBBatchInsertBuilder {
    fields: QueryBuilderConfBatchField[];
    tables: JoinableTable[];
}
export function ibBatchNew(): QBBatchInsertBuilder {
    return {
        fields: [],
        tables: [],
    };
}
export function ibBatchFormation<T extends {
    [s: string]: (confobj: QBBatchInsertBuilder, ...args: any[]) => any;
}>(obj: T, classConf: QBBatchInsertBuilder) {
    return classLikeFormation(obj, classConf);
}
export function ibSetFieldRows(confObj: QBBatchInsertBuilder, arr: Array<Omit<QueryBuilderField, "val"> & { key: string }>, values: KeyValueJson[], rawMap: Map<string, string> = new Map()) {
    if (confObj.fields.length !== 0) {
        throw new LeQuerybuilderAuroraMysqlDataApiError(LeQuerybuilderAuroraMysqlDataApiErrorEnum.FormatError);
    }
    const fieldMap: Map<string, {
        colName: string;
        raw?: string;
        type?: QueryBuilderBaseParamEnum,
        vals: any[];
    }> = new Map();
    for (const json of values) {
        for (const field of arr) {
            if (rawMap.has(field.key)) {
                if (!fieldMap.has(field.key)) {
                    fieldMap.set(field.key, {
                        colName: field.key,
                        raw: rawMap.get(field.key),
                        vals: [],
                    });
                }
            }
            if (typeof json[field.key] === "undefined") {
                throw new LeQuerybuilderAuroraMysqlDataApiError(LeQuerybuilderAuroraMysqlDataApiErrorEnum.SetFieldTypeError);
            }
            if (fieldMap.has(field.key)) {
                const obj = fieldMap.get(field.key);
                obj.vals.push(json[field.key]);
            } else {
                fieldMap.set(field.key, {
                    colName: field.name,
                    type: field.type,
                    vals: [json[field.key]],
                });
            }
        }
    }
    for (const [fieldKey, mapVal] of fieldMap) {
        confObj.fields.push({
            name: mapVal.colName,
            raw: mapVal.raw,
            type: mapVal.type,
            vals: mapVal.vals,
        });
    }
}

export function ibBatchFormat(confObj: QBBatchInsertBuilder) {
    if (confObj.tables.length === 0) {
        throw new LeQuerybuilderAuroraMysqlDataApiError(LeQuerybuilderAuroraMysqlDataApiErrorEnum.FormatError);
    }
    if (confObj.fields.length === 0) {
        throw new LeQuerybuilderAuroraMysqlDataApiError(LeQuerybuilderAuroraMysqlDataApiErrorEnum.FormatError);
    }
    const parameterSets: RDSDataService.SqlParameter[][] = [];
    const fieldArr = [];
    const valueArr = [];
    let totalVal = 0;
    let paramCounter = 0;
    const paramNameMapForField: Map<string, string> = new Map();
    for (const field of confObj.fields) {
        fieldArr.push(field.name);
        if (typeof field.raw === "undefined") {
            totalVal = field.vals.length;
            const paramName = "p" + paramCounter++;
            paramNameMapForField.set(field.name, paramName);
            valueArr.push(":" + paramName);
        } else if (typeof field.raw !== "string") {
            throw new LeQuerybuilderAuroraMysqlDataApiError(
                LeQuerybuilderAuroraMysqlDataApiErrorEnum.FormatError);
        } else {
            valueArr.push(field.raw);
        }
    }
    for (let i = 0; i < totalVal; i++) {
        const parameters: RDSDataService.SqlParameter[] = [];
        for (const field of confObj.fields) {
            const paramType = field.type;
            if (typeof field.raw !== "undefined") {
                continue;
            }
            const paramName = paramNameMapForField.get(field.name);
            const curVal = field.vals[i];
            const val: RDSDataService.Field = {};
            if (curVal == null) {
                val.isNull = true;
            } else {
                switch (paramType) {
                    case QueryBuilderBaseParamEnum.Blob:
                        val.blobValue = curVal;
                        break;
                    case QueryBuilderBaseParamEnum.Double:
                        val.doubleValue = curVal;
                        break;
                    case QueryBuilderBaseParamEnum.Long:
                        val.longValue = curVal;
                        break;
                    case QueryBuilderBaseParamEnum.String:
                        val.stringValue = curVal;
                        break;
                    case QueryBuilderBaseParamEnum.Boolean:
                        val.booleanValue = curVal;
                        break;
                    default:
                        throw new LeQuerybuilderAuroraMysqlDataApiError(
                            LeQuerybuilderAuroraMysqlDataApiErrorEnum.SetFieldTypeError);
                }
            }
            parameters.push({
                name: paramName,
                value: val,
            });
        }
        parameterSets.push(parameters);
    }
    const tablePart = formatJoinableTables(confObj);
    return {
        parameterSets,
        sql: `INSERT INTO ${tablePart.str} (${fieldArr.join(",")}) VALUES (${valueArr.join(",")})`,
    };
}