import dbHandler from "../db-handler";
import type {
    BunMariaDBConfig,
    DBResponseObject,
    SQLInsertGenReturn,
} from "../../types";
import sqlInsertGenerator from "../../utils/sql-insert-generator";
import { sanitizeHtmlFieldsBatch } from "../../utils/sanitize-html-fields";
import grabDuplicateSafeInsertSql from "../grab-duplicate-safe-insert-sql";

type Params<
    Schema extends { [k: string]: any } = { [k: string]: any },
    Table extends string = string,
> = {
    table: Table;
    data: Schema[];
    update_on_duplicate?: boolean;
    config?: BunMariaDBConfig;
};

export default async function DbInsert<
    Schema extends { [k: string]: any } = { [k: string]: any },
    Table extends string = string,
>({
    table,
    data,
    update_on_duplicate,
    config,
}: Params<Schema, Table>): Promise<DBResponseObject> {
    let sqlObj: SQLInsertGenReturn | null = null;

    try {
        const sanitizedData = sanitizeHtmlFieldsBatch({
            table,
            data,
            config,
        });

        const finalData: { [k: string]: any }[] = sanitizedData.map((d) => ({
            created_at: Date.now(),
            updated_at: Date.now(),
            ...d,
        }));

        sqlObj =
            sqlInsertGenerator({
                tableName: table,
                data: finalData as any[],
            }) || null;

        if (!sqlObj) {
            return {
                success: false,
                msg: "No insert SQL generated",
            };
        }

        let sql = sqlObj.query;

        if (update_on_duplicate && data[0]) {
            sql = await grabDuplicateSafeInsertSql({ data, table, sql });
        }

        sql += ` RETURNING *`;

        const res = await dbHandler({
            query: sql,
            values: sqlObj.values,
            config,
        });

        if (!res.success) {
            return {
                success: false,
                msg: "Database insert failed",
                debug: {
                    sqlObj,
                },
            };
        }

        return {
            ...res,
            success: Boolean(
                res?.insert_return?.affected_rows ||
                res.insert_return?.last_insert_id,
            ),
            debug: {
                sqlObj,
            },
        };
    } catch (error: any) {
        return {
            success: false,
            error: error.message,
            debug: {
                sqlObj,
            },
        };
    }
}