import sqlDeleteGenerator from "../../functions/dsql/sql/sql-delete-generator";
import {
    APIResponseObject,
    DsqlCrudParam,
    PostInsertReturn,
} from "../../types";
import dsqlCrudGet from "./crud-get";
import connDbHandler from "../db/conn-db-handler";
import addDbEntry from "../../functions/backend/db/addDbEntry";
import updateDbEntry from "../../functions/backend/db/updateDbEntry";

export default async function dsqlCrud<
    T extends { [key: string]: any } = { [key: string]: any },
    K extends string = string
>(params: DsqlCrudParam<T, K>): Promise<APIResponseObject> {
    const {
        action,
        data,
        table,
        targetValue,
        sanitize,
        targetField,
        targetId,
        dbFullName,
        deleteData,
        batchData,
        deleteKeyValues,
        debug,
    } = params;

    const finalData = (sanitize ? sanitize({ data }) : data) as T;
    const finalBatchData = (
        sanitize ? sanitize({ batchData }) : batchData
    ) as T[];

    const DB_CONN = global.DSQL_READ_ONLY_DB_CONN || global.DSQL_DB_CONN;

    switch (action) {
        case "get":
            return await dsqlCrudGet(params);

        // case "batch-get":
        //     return await dsqlCrudBatchGet(params);

        case "insert":
            const INSERT_RESULT = await addDbEntry({
                data: finalData,
                batchData: finalBatchData,
                tableName: table,
                dbFullName,
                debug,
            });
            return INSERT_RESULT;

        case "update":
            delete data?.id;

            const UPDATE_RESULT = await updateDbEntry({
                data: finalData,
                tableName: table,
                dbFullName,
                identifierColumnName: (targetField || "id") as string,
                identifierValue: String(targetValue || targetId),
                debug,
            });

            return UPDATE_RESULT;

        case "delete":
            const deleteQuery = sqlDeleteGenerator({
                data: targetId
                    ? { id: targetId }
                    : targetField && targetValue
                    ? { [targetField]: targetValue }
                    : deleteData,
                tableName: table,
                dbFullName,
                deleteKeyValues,
            });

            const res = (await connDbHandler(
                DB_CONN,
                deleteQuery?.query,
                deleteQuery?.values
            )) as PostInsertReturn;

            return {
                success: Boolean(res.affectedRows),
                payload: res,
                queryObject: {
                    sql: deleteQuery?.query || "",
                    params: deleteQuery?.values || [],
                },
            };

        default:
            return {
                success: false,
                payload: undefined,
                msg: "Invalid action",
            };
    }
}