const qrcode = require("qrcode-terminal");
const fs = require("fs");

// const path = require("path");
const { Client } = require("whatsapp-web.js");
// const SESSION_FOLDER = path.join(__dirname, "../data/");
// const SESSION_FILE_PATH = path.join(__dirname, "../data/session.json");
// const sessions = require("../api/session_data");
const { parseMultipartData, sanitizeEntity } = require("strapi-utils");

var client;
//Login Session when there is Session File

function callbacks(client, callback,type="create") {
    let sessionData;
    client.on("auth_failure", (session) => {
        console.log("auth_failure");
        // clearFileSession(phoneNumber);
        return callback(
            JSON.stringify({
                STATUS: 0,
                TYPE: "AUTH_FAILURE",
                DATA: "SESSION HAS BEEN ENDED , PLEASE CREATE A NEW ONE !",
            })
        );
    });
    client.on("disconnected", async function (session) {
        console.log("disconnected from loading");
        if (session == "UNPAIRED") {
            try {
                if (client && client.info) {
                    getID = await strapi
                        .query("session-data")
                        .findOne({ phonenumber: client.info.wid.user });

                    if (getID) {
                        let id = getID["id"];
                        await strapi.query("session-data").delete({ id });
                    }
                }
            } catch (e) {}
        }
    });

    client.on("ready", () => {
        var clientInfo = client.info;
        clientInfo["sessionData"] = sessionData;
        return callback(
            JSON.stringify({
                STATUS: 1,
                TYPE: "READY",
                DATA: (type=="create")?clientInfo:client,
            })
        );
    });
    client.on("message", async (msg) => {
        console.log("MESSAGE RECEIVED", msg.body);
    });
    client.on("qr", (qr) => {
        return callback(
            JSON.stringify({ STATUS: 1, TYPE: "QR_AUTH", DATA: qr })
        );
    });

    client.on("change_state", (state) => {
        console.log(`state => ${state}`);
    });
    client.on("authenticated", (session) => {
        try {
            sessionData = session;
            // fs.writeFileSync(SESSION_FILE_PATH, JSON.stringify(session));
        } catch (e) {
            return callback(
                JSON.stringify({
                    STATUS: 0,
                    TYPE: "AUTHENTICATED_ERROR",
                    DATA: e.message,
                })
            );
        }
    });
}

var loadClient = async function (clientSessionData, callback) {
    try {
        // if(!client){
        //     console.log(client.info);
        //     return callback({"STATUS" : 1 , "TYPE" : "READY" , "DATA" : client.info})
        // }
        // let sessionPath = path.join(SESSION_FOLDER, `${phoneNumber}.json`);
        // if (fs.existsSync(sessionPath)) {
        // sessionData = require(sessionPath);

        client = new Client({
            puppeteer: {
                args: ["--no-sandbox", "--disable-setuid-sandbox"],
            },
            session: clientSessionData,
            restartOnAuthFail: true,
        });

        callbacks(client, callback,"load");
        console.log("initialize");
        client.initialize();
    } catch (e) {
        return callback({
            STATUS: 0,
            TYPE: "ERROR",
            DATA: e.message,
        });
    }
};

var createNewClient = async function (callback) {
    try {
        client = new Client({
            puppeteer: {
                args: ["--no-sandbox", "--disable-setuid-sandbox"],
            },
        });

        callbacks(client, callback);

        client.initialize();
        //var clientInfo = await getClientInfo();
        //return clientInfo;
    } catch (e) {
        return callback({ STATUS: 0, TYPE: "READY", DATA: e.message });
    }
};

var sendMessage = async function (phone_number, textMessage) {
    try {
        if (!client.info) {
            throw { message: "Client Is Not Ready !" };
        }
        var phoneNumber = reformatMobilePhone(phone_number);
        // var state = await client.isRegisteredUser(phoneNumber);
        // console.log(state);
        await client.sendMessage(phoneNumber, textMessage);

        return { STATUS: 1, DATA: "Messages Succesfully send !" };
    } catch (e) {
        return { STATUS: 0, DATA: e.message };
    }
};

var getClientInfo = function () {
    try {
        var a;
        while (!a) {
            a = client.info;
        }
        return { STATUS: 1, DATA: a };
    } catch (e) {
        return { STATUS: 0, DATA: e.message };
    }
};

var getClientState = async function () {
    try {
        if (!client.info) {
            throw { message: "Client Is Not Ready !" };
        }
        let state = await client.getState();
        return { STATUS: 1, DATA: state };
    } catch (e) {
        return { STATUS: 0, DATA: e.message };
    }
};

var destroySession = async function (phoneNumber) {
    try {
        if (client && client.info) {
            await client.logout();
            await client.destroy();
            clearFileSession(phoneNumber);
            return { STATUS: 1, DATA: "Session cleared" };
        } else throw { message: "Client Is Not Ready !" };
    } catch (e) {
        return { STATUS: 0, DATA: e.message };
    }
};

function reformatMobilePhone(phoneNumber) {
    var newPhoneNumber;
    if (phoneNumber[0].toString() == "0") {
        newPhoneNumber = "62" + phoneNumber.substring(1) + "@c.us";
    } else if (phoneNumber[0] == "+") {
        newPhoneNumber = phoneNumber.substring(1) + "@c.us";
    } else {
        newPhoneNumber = phoneNumber + "@c.us";
    }

    return newPhoneNumber;
}

function clearFileSession(phoneNumber) {
    try {
        let sessionPath = path.join(SESSION_FOLDER, `${phoneNumber}.json`);
        if (fs.existsSync(sessionPath)) {
            console.log(`clearing session ${phoneNumber}`);
            fs.unlinkSync(sessionPath);
        }
    } catch (e) {
        throw e;
    }
}

module.exports = {
    sendMessage: sendMessage,
    createNewClient: createNewClient,
    loadClient: loadClient,
    getClientInfo: getClientInfo,
    destroySession: destroySession,
    getClientState: getClientState,
    getClientState: getClientState,
};