import sqlGenerator from "../../functions/dsql/sql/sql-generator";
import { APIResponseObject, DsqlCrudParam } from "../../types";
import connDbHandler, { ConnDBHandlerQueryObject } from "../db/conn-db-handler";
import checkArrayDepth from "../check-array-depth";
import parseDbResults from "../../functions/backend/parseDbResults";

export default async function <
    T extends { [key: string]: any } = { [key: string]: any }
>({
    table,
    query,
    count,
    countOnly,
    dbFullName,
    tableSchema,
}: Omit<
    DsqlCrudParam<T>,
    "action" | "data" | "sanitize"
>): Promise<APIResponseObject> {
    let queryObject: ReturnType<Awaited<typeof sqlGenerator>> | undefined;

    queryObject = sqlGenerator({
        tableName: table,
        genObject: query,
        dbFullName,
    });

    let connQueries: ConnDBHandlerQueryObject[] = [
        {
            query: queryObject?.string,
            values: queryObject?.values || [],
        },
    ];

    const countQueryObject =
        count || countOnly
            ? sqlGenerator({
                  tableName: table,
                  genObject: query,
                  count: true,
                  dbFullName,
              })
            : undefined;

    if (count && countQueryObject) {
        connQueries.push({
            query: countQueryObject.string,
            values: countQueryObject.values,
        });
    } else if (countOnly && countQueryObject) {
        connQueries = [
            {
                query: countQueryObject.string,
                values: countQueryObject.values,
            },
        ];
    }

    const res = await connDbHandler(undefined, connQueries);

    const parsedRes = checkArrayDepth(res, 2)
        ? parseDbResults({ unparsedResults: res[0], tableSchema })
        : res[0];
    const parsedBatchRes = checkArrayDepth(res, 3)
        ? res.map((_r: any[][]) => {
              return parseDbResults({ unparsedResults: _r[0], tableSchema });
          })
        : res;

    const isSuccess = Array.isArray(res) && Array.isArray(res[0]);

    return {
        success: isSuccess,
        payload: isSuccess ? (countOnly ? null : parsedRes) : null,
        batchPayload: isSuccess ? (countOnly ? null : parsedBatchRes) : null,
        error: isSuccess
            ? undefined
            : typeof res == "object" && !Array.isArray(res)
            ? res?.error
            : undefined,
        errors: res?.errors,
        queryObject: {
            sql: queryObject?.string,
            params: queryObject?.values,
        },
        count: isSuccess
            ? res[1]?.[0]?.["COUNT(*)"]
                ? res[1][0]["COUNT(*)"]
                : res[0]?.[0]?.["COUNT(*)"]
                ? res[0][0]["COUNT(*)"]
                : undefined
            : undefined,
    };
}