"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = apiCreateUser;
const grab_required_database_schemas_1 = require("../../../shell/createDbFromSchema/grab-required-database-schemas");
const addUsersTableToDb_1 = __importDefault(require("../../backend/addUsersTableToDb"));
const addDbEntry_1 = __importDefault(require("../../backend/db/addDbEntry"));
const updateUsersTableSchema_1 = __importDefault(require("../../backend/updateUsersTableSchema"));
const dbHandler_1 = __importDefault(require("../../backend/dbHandler"));
const hashPassword_1 = __importDefault(require("../../dsql/hashPassword"));
const validate_email_1 = __importDefault(require("../../email/fns/validate-email"));
/**
 * # API Create User
 */
function apiCreateUser(_a) {
    return __awaiter(this, arguments, void 0, function* ({ encryptionKey, payload, database, dsqlUserID, verify, }) {
        var _b;
        const finalEncryptionKey = encryptionKey || process.env.DSQL_ENCRYPTION_PASSWORD;
        if (!finalEncryptionKey) {
            return {
                success: false,
                msg: "No encryption key provided",
                payload: null,
            };
        }
        if (!(finalEncryptionKey === null || finalEncryptionKey === void 0 ? void 0 : finalEncryptionKey.match(/.{8,}/))) {
            return {
                success: false,
                msg: "Encryption key must be at least 8 characters long",
                payload: null,
            };
        }
        const targetDbSchema = (0, grab_required_database_schemas_1.grabPrimaryRequiredDbSchema)({
            dbSlug: database,
            userId: dsqlUserID,
            dbId: dsqlUserID ? undefined : 1,
        });
        if (!(targetDbSchema === null || targetDbSchema === void 0 ? void 0 : targetDbSchema.id)) {
            return {
                success: false,
                msg: "targetDbSchema not found",
                payload: null,
            };
        }
        const dbFullName = targetDbSchema.dbFullName;
        if (!dbFullName) {
            return {
                success: false,
                msg: "dbFullName not found",
                payload: null,
            };
        }
        const hashedPassword = (0, hashPassword_1.default)({
            encryptionKey: finalEncryptionKey,
            password: String(payload.password),
        });
        payload.password = hashedPassword;
        const fieldsQuery = `SHOW COLUMNS FROM ${dbFullName}.users`;
        let fields = (yield (0, dbHandler_1.default)({
            query: fieldsQuery,
            database: dbFullName,
        }));
        if (!(fields === null || fields === void 0 ? void 0 : fields[0])) {
            const newTable = yield (0, addUsersTableToDb_1.default)({
                userId: dsqlUserID,
                database: dbFullName,
                payload: payload,
                dbId: targetDbSchema.id,
            });
            if (!newTable) {
                return {
                    success: false,
                    msg: "Could not create users table",
                    payload: null,
                };
            }
        }
        const fieldsTitles = fields.map((fieldObject) => fieldObject.Field);
        let invalidField = null;
        for (let i = 0; i < Object.keys(payload).length; i++) {
            const key = Object.keys(payload)[i];
            if (!fieldsTitles.includes(key)) {
                yield (0, updateUsersTableSchema_1.default)({
                    userId: dsqlUserID,
                    database: dbFullName,
                    newPayload: {
                        [key]: payload[key],
                    },
                    dbId: targetDbSchema.id,
                });
            }
        }
        if (invalidField) {
            return {
                success: false,
                msg: `${invalidField} is not a valid field!`,
            };
        }
        const existingUserQuery = `SELECT * FROM ${dbFullName}.users WHERE email = ?${payload.username ? " OR username = ?" : ""}`;
        const existingUserValues = payload.username
            ? [payload.email, payload.username]
            : [payload.email];
        const existingUser = (yield (0, dbHandler_1.default)({
            query: existingUserQuery,
            values: existingUserValues,
            database: dbFullName,
        }));
        if (existingUser === null || existingUser === void 0 ? void 0 : existingUser[0]) {
            return {
                success: false,
                msg: "User Already Exists",
                payload: null,
            };
        }
        const isEmailValid = yield (0, validate_email_1.default)({ email: payload.email });
        if (!isEmailValid.isValid) {
            return {
                success: false,
                msg: isEmailValid.message,
                payload: null,
            };
        }
        const addUser = yield (0, addDbEntry_1.default)({
            dbFullName: dbFullName,
            tableName: "users",
            data: Object.assign(Object.assign({}, payload), { image: process.env.DSQL_DEFAULT_USER_IMAGE ||
                    "/images/user-preset.png", image_thumbnail: process.env.DSQL_DEFAULT_USER_IMAGE ||
                    "/images/user-preset-thumbnail.png", verification_status: verify ? 1 : 0 }),
        });
        if ((_b = addUser === null || addUser === void 0 ? void 0 : addUser.payload) === null || _b === void 0 ? void 0 : _b.insertId) {
            const newlyAddedUserQuery = `SELECT id,uuid,first_name,last_name,email,username,image,image_thumbnail,verification_status FROM ${dbFullName}.users WHERE id='${addUser.payload.insertId}'`;
            const newlyAddedUser = (yield (0, dbHandler_1.default)({
                query: newlyAddedUserQuery,
                values: [],
                database: dbFullName,
            }));
            return Object.assign(Object.assign({}, addUser), { payload: newlyAddedUser[0] });
        }
        else {
            return Object.assign(Object.assign({}, addUser), { msg: "Could not create user" });
        }
    });
}