// captchaSystem.js - PokéVault Node.js Standalone Captcha Solver
const axios = require("axios");
const https = require("https");
const { EmbedBuilder, WebhookClient } = require("discord.js");
const config = require("../config");
const { HttpsProxyAgent } = require('https-proxy-agent');

async function solveCaptchaCore(clientOrToken, uid) {
  try {
    const HCAPTCHA_SITEKEY = '24e07a58-bdb4-492c-96aa-33b0ea7e1b2c';
    const HCAPTCHA_HOST = 'verify.poketwo.net';
    const solverUrl = config.solverApiUrl || 'http://148.113.8.216:8081';

    console.log("[Pokevault] Starting end-to-end captcha solve...");
    console.log(`   UID: ${uid}`);

    const startTime = Date.now();

    if (!config.solverApiKey) {
      return { success: false, error: "No API key provided in config.js (solverApiKey)" };
    }

    // -- STEP 1 & 3 Combined: Solve hCaptcha AND Submit to Poketwo --
    console.log("[Pokevault] Step 1: Solving hCaptcha & Submitting via /solve_and_submit...");
    let solveResult;
    try {
      const response = await axios.post(`${solverUrl}/solve_and_submit`, {
        uid: uid,
        sitekey: HCAPTCHA_SITEKEY,
        host: HCAPTCHA_HOST,
        user_agent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36 Not_A Brand/24"
      }, {
        headers: {
          "Authorization": `Bearer ${config.solverApiKey}`,
          "Content-Type": "application/json"
        },
        timeout: 300000
      });

      solveResult = response.data;
      
      if (solveResult.quota_warning && config.captchawebhook) {
        try {
          const warnClient = new WebhookClient({ url: config.captchawebhook });
          warnClient.send({
            content: "@here [WARNING] API Quota Warning: Your Pokevault Captcha Solver API key has reached 90% of its daily solve limit!"
          }).catch(err => console.error("Failed to send quota warning webhook:", err));
        } catch (err) {
          console.error("Invalid captchawebhook format in config:", err);
        }
      }
    } catch (e) {
      if (e.response && e.response.status === 403) {
        return { success: false, error: "API Key has run out of solves!" };
      }
      if (e.response && e.response.status === 401) {
        return { success: false, error: "Invalid API Key!" };
      }
      return { success: false, error: "Solver error: " + e.message };
    }

    if (!solveResult.success) {
      return { success: false, error: "Solve/Submit failed: " + (solveResult.error || "Unknown error") };
    }
    
    const oauthUrl = solveResult.location;
    if (!oauthUrl || !oauthUrl.includes("discord.com/oauth2")) {
      return { success: false, error: "No Discord OAuth URL received from solver" };
    }

    console.log(`[SUCCESS] Step 1 & 3 done: Captcha accepted by Poketwo! (${solveResult.solveResponse?.attempts || 1} attempts)`);

    // -- STEP 2: Pre-authorize Discord OAuth to get the callback URL --
    console.log("[Pokevault] Step 2: Preparing Discord OAuth Client...");

    let clientToUse;
    let isTempClient = false;

    if (typeof clientOrToken === 'string') {
      const { Client } = require('discord.js-selfbot-v13');
      clientToUse = new Client();
      isTempClient = true;
    } else {
      clientToUse = clientOrToken;
    }

    // ── STEP 4: Authorize Discord OAuth + navigate callback ──
    console.log("⏳ Step 4: Authorizing Discord OAuth...");

    const authorizeAndCallback = async (clientInstance) => {
      try {
        const authResult = await clientInstance.authorizeURL(oauthUrl, {
          authorize: true,
          integration_type: 0,
          permissions: '0',
        });

        if (!authResult || !authResult.location) {
          console.log("[OAuth] authorizeURL returned no location");
          return null;
        }

        const callbackUrl = authResult.location;
        console.log("[OAuth] Discord authorized! Callback URL:", callbackUrl.substring(0, 80) + "...");

        // Navigate to callback via pure HTTP using cf_get
        console.log("[OAuth] Navigating callback via pure HTTP cf_get...");
        try {
          const callbackRes = await axios.post(`${solverUrl}/cf_get`, {
            url: callbackUrl,
            headers: {
              "Cookie": solveResult.cookieString,
              "User-Agent": solveResult.userAgent || "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36 Not_A Brand/24",
              "Referer": "https://discord.com/"
            },
            proxy: solveResult.proxyUsed
          }, {
            headers: {
              "Authorization": `Bearer ${config.solverApiKey}`,
              "Content-Type": "application/json"
            },
            timeout: 60000 
          });

          const callbackData = callbackRes.data;
          console.log("[OAuth] callback status:", callbackData.statusCode);

          if (callbackData.success) {
             const cbHeaders = callbackData.headers || {};
             const finalUrl = cbHeaders['location'] || cbHeaders['Location'] || callbackUrl;
             return finalUrl;
          }
        } catch (e) {
          console.log("[OAuth] pure HTTP callback error:", e.message);
        }

        console.log("[OAuth] Callback navigation failed, but captcha was accepted by Poketwo.");
        return "captcha_accepted_oauth_partial";
      } catch (e) {
        console.log("[OAuth] Error:", e.message);
        return null;
      }
    };

    let finalUrl = null;

    if (isTempClient) {
      finalUrl = await new Promise((resolve) => {
        const timeout = setTimeout(() => {
          try { clientToUse.ws.destroy(); } catch (_) { }
          resolve(null);
        }, 120000);

        clientToUse.login(clientOrToken).catch((err) => {
          console.error("[ERROR] Discord Token Login failed:", err);
          clearTimeout(timeout);
          resolve(null);
        });

        clientToUse.once('ready', async () => {
          try {
            const result = await authorizeAndCallback(clientToUse);
            resolve(result);
          } catch (e) {
            console.error("[ERROR] OAuth Error:", e);
            resolve(null);
          } finally {
            clearTimeout(timeout);
            try { clientToUse.ws.destroy(); } catch (_) { }
          }
        });
      });
    } else {
      try {
        finalUrl = await authorizeAndCallback(clientToUse);
      } catch (e) {
        console.error("OAuth error:", e);
      }
    }

    if (finalUrl) {
      const timeTakenSec = ((Date.now() - startTime) / 1000).toFixed(2);
      return { success: true, result: finalUrl, timeTaken: timeTakenSec };
    } else {
      return { success: false, error: "Discord OAuth failed or timed out", isLocalError: true };
    }

  } catch (error) {
    console.error("[ERROR] Captcha solve error:", error);
    return { success: false, error: error.message || "Local solver error" };
  }
}

async function solveCaptcha(clientOrToken, uid) {
  let lastResult = null;
  for (let attempt = 1; attempt <= 3; attempt++) {
    if (attempt > 1) {
      console.log(`\n[RETRY] [Attempt ${attempt}/3] Retrying captcha for UID: ${uid} in 3 seconds...`);
      await new Promise(r => setTimeout(r, 3000));
    }

    lastResult = await solveCaptchaCore(clientOrToken, uid);

    if (lastResult.success) {
      return lastResult;
    }

    console.log(`[FAILED] Attempt ${attempt} failed: ${lastResult.error}`);

    if (lastResult.error && (lastResult.error.includes("API key provided") || lastResult.error.includes("run out of solves") || lastResult.error.includes("Invalid API Key") || lastResult.isLocalError)) {
      console.log(`[STOP] Stopping retries to prevent double charging.`);
      break;
    }
  }
  return lastResult;
}

module.exports = { solveCaptcha };