// Modal state variables
let isModalOpen = false;
let pendingAction = null; // Can be 'success' or 'error'
let storedErrorMessage = '';
let storedRedirectUrl = '';
const REDIRECT_DELAY = 1488;

function workerFunction() {
  self.onmessage = function (e) {
    const { type, data } = e.data;

    if (type === 'pow') {
      const { challenge, salt, startNonce, endNonce, target, batchId } = data;
      let count = 0;
      let solution = null;

      processNextNonce(startNonce);

      function processNextNonce(nonce) {
        const input = String(challenge) + String(salt) + nonce.toString();
        const msgBuffer = new TextEncoder().encode(input);

        crypto.subtle
          .digest('SHA-256', msgBuffer)
          .then((hashBuffer) => {
            const hashArray = Array.from(new Uint8Array(hashBuffer));
            const result = hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');

            count++;

            if (result.startsWith(target)) {
              solution = { nonce: nonce.toString(), found: true };
              self.postMessage({
                type: 'pow_result',
                solution: solution,
                count: count,
                batchId: batchId,
              });
              return;
            }

            if (count % 1000 === 0) {
              self.postMessage({
                type: 'progress',
                count: count,
                batchId: batchId,
              });
            }

            if (nonce < endNonce && !solution) {
              setTimeout(() => processNextNonce(nonce + 1), 0);
            } else if (!solution) {
              self.postMessage({
                type: 'pow_result',
                solution: null,
                count: count,
                batchId: batchId,
              });
            }
          })
          .catch((err) => {
            self.postMessage({
              type: 'error',
              error: 'Crypto API error: ' + err.message,
            });
          });
      }
    } else {
      self.postMessage({ type: 'error', error: 'Unknown message type: ' + type });
    }
  };
}
const workerCode = '(' + workerFunction.toString() + ')()';

function posWorkerFunction() {
  self.onmessage = async function (e) {
    const { type, seedHex, isDecoy } = e.data;
    if (type === 'pos') {
      const minMB = 48,
        maxMB = 160;
      let seedInt = parseInt(seedHex.slice(0, 8), 16);
      if (isNaN(seedInt)) seedInt = Math.floor(Math.random() * (maxMB - minMB + 1));
      const CHUNK_MB = isDecoy
        ? minMB + ((seedInt * 3 + 17) % (maxMB - minMB + 1))
        : minMB + (seedInt % (maxMB - minMB + 1));
      const CHUNK_SIZE = CHUNK_MB * 1024 * 1024;
      const chunkCount = 4 + (seedInt % 5);
      const chunkSize = Math.floor(CHUNK_SIZE / chunkCount);
      const FILL_STEP_4K = 4096,
        FILL_STEP_1K = 1024;
      const FILL_STEP_SWITCH = 35 * 1024 * 1024;
      const runs = 3;

      const mainBuf = new ArrayBuffer(CHUNK_SIZE);
      const view = new Uint8Array(mainBuf);
      const pressureBuf = new ArrayBuffer(16 * 1024 * 1024);
      const pressureView = new Uint8Array(pressureBuf);

      const hashes = [];
      const times = [];
      for (let r = 0; r < runs; r++) {
        const prng = seededPRNG(seedHex + r.toString(16));

        const order = Array.from({ length: chunkCount }, (_, i) => i);
        for (let i = order.length - 1; i > 0; i--) {
          const j = prng() % (i + 1);
          [order[i], order[j]] = [order[j], order[i]];
        }

        const t0 = performance.now();
        for (let c = 0; c < chunkCount; c++) {
          const idx = order[c];
          const start = idx * chunkSize;
          const end = idx === chunkCount - 1 ? CHUNK_SIZE : start + chunkSize;
          const step = start < FILL_STEP_SWITCH ? FILL_STEP_4K : FILL_STEP_1K;
          for (let i = start; i < end; i += step) view[i] = prng() & 0xff;
        }
        const hashBuf = await crypto.subtle.digest('SHA-256', view);
        const t2 = performance.now();
        hashes.push(
          Array.from(new Uint8Array(hashBuf))
            .map((b) => b.toString(16).padStart(2, '0'))
            .join(''),
        );
        times.push(Math.round(t2 - t0));

        for (let i = 0; i < pressureView.length; i += 4096) pressureView[i] = prng() & 0xff;
      }

      self.postMessage({ type: 'pos_result', hashes, times });
    }
  };
  function seededPRNG(seedHex) {
    const s = [];
    for (let i = 0; i < 4; i++) s[i] = parseInt(seedHex.substr(i * 8, 8), 16) >>> 0;
    function rotl(x, k) {
      return ((x << k) | (x >>> (32 - k))) >>> 0;
    }
    return function () {
      const t = s[1] << 9;
      let r = (s[0] * 5) >>> 0;
      r = (rotl(r, 7) * 9) >>> 0;
      const tmp = s[0] ^ s[2];
      s[2] ^= s[1];
      s[1] ^= s[3];
      s[0] ^= s[1];
      s[3] ^= tmp;
      s[2] ^= t;
      s[3] = rotl(s[3], 11);
      return r >>> 0;
    };
  }
}
const posWorkerCode = '(' + posWorkerFunction.toString() + ')()';

document.addEventListener('DOMContentLoaded', function () {
  setTimeout(initVerification, 650);

  // Modal elements
  const infoButton = document.getElementById('infoBtn');
  const infoModal = document.getElementById('infoModal');
  const modalCloseButton = document.getElementById('modalCloseBtn');

  if (infoButton) {
    infoButton.addEventListener('click', () => {
      if (isModalOpen) {
        closeModal();
      } else {
        isModalOpen = true;
        if (infoModal) infoModal.classList.add('active');
      }
    });
  }

  if (modalCloseButton) {
    modalCloseButton.addEventListener('click', closeModal);
  }

  // Close modal if overlay is clicked
  if (infoModal) {
    infoModal.addEventListener('click', (event) => {
      if (event.target === infoModal) {
        closeModal();
      }
    });
  }

  function closeModal() {
    if (infoModal) infoModal.classList.remove('active');
    isModalOpen = false;
    if (pendingAction === 'success') {
      triggerStoredSuccess();
    } else if (pendingAction === 'error') {
      triggerStoredError(storedErrorMessage);
    }
    pendingAction = null; // Reset after handling
  }

  // Moved triggerStoredSuccess and triggerStoredError to this scope
  function triggerStoredSuccess() {
    document.querySelector('.container').classList.add('success');
    const statusEl = document.getElementById('status');
    if (statusEl) statusEl.textContent = 'Redirecting'; // Ensure status is updated
    if (storedRedirectUrl) {
      setTimeout(() => {
        window.location.href = storedRedirectUrl;
      }, REDIRECT_DELAY); // Ensure REDIRECT_DELAY is accessible or define it here
    }
  }

  function triggerStoredError(message) {
    const container = document.querySelector('.container');
    const statusEl = document.getElementById('status');
    const spinnerContainer = document.querySelector('.spinner-container');

    container.classList.add('error');
    container.classList.remove('success');

    if (statusEl) {
      statusEl.style.display = 'inline-block';
      statusEl.textContent = 'Error';
      statusEl.classList.add('error');
      statusEl.classList.remove('success');
    }

    let errorDetails = document.getElementById('error-details');
    if (!errorDetails && spinnerContainer) {
      errorDetails = document.createElement('div');
      errorDetails.id = 'error-details';
      errorDetails.className = 'error-details';
      spinnerContainer.appendChild(errorDetails);
    }
    if (errorDetails) {
      // errorDetails.textContent = message; // Display the specific error message
      errorDetails.style.display = 'block';
    }
    // Ensure any running workers are stopped on error
  }

  function initVerification() {
    const dataEl = document.getElementById('verification-data');
    const targetPath = dataEl.getAttribute('data-target');
    const requestID = dataEl.getAttribute('data-request-id');

    startVerification();

    async function startVerification() {
      try {
        const challengeResponse = await fetch(
          '/api/challenge?id=' + encodeURIComponent(requestID),
          { method: 'GET', headers: { Accept: 'application/json' }, credentials: 'include' },
        );

        if (!challengeResponse.ok) {
          throw new Error('Failed to get challenge parameters');
        }

        const challengeData = await challengeResponse.json();

        const verifier = new Verifier(challengeData, targetPath, requestID);
        verifier.start();
      } catch (error) {
        showError('Verification setup failed: ' + error.message);
      }
    }

    function createWorker() {
      const blob = new Blob([workerCode], { type: 'text/javascript' });
      return new Worker(URL.createObjectURL(blob));
    }

    function createPosWorker() {
      const blob = new Blob([posWorkerCode], { type: 'text/javascript' });
      return new Worker(URL.createObjectURL(blob));
    }

    function showError(message) {
      const container = document.querySelector('.container');
      const statusEl = document.getElementById('status');
      const spinnerContainer = document.querySelector('.spinner-container');

      storedErrorMessage = message; // Store for later

      if (isModalOpen) {
        pendingAction = 'error';
        if (statusEl) {
          statusEl.textContent = 'Error'; // Generic message while modal is open
          statusEl.style.display = 'inline-block'; // Make sure status is visible
          statusEl.classList.remove('success'); // Ensure no success styling
          statusEl.classList.add('error'); // Add error styling for text color
        }
        // Do not show full error details or animations yet
        return;
      }

      // Proceed with normal error display if modal is not open
      container.classList.add('error');
      container.classList.remove('success');

      if (statusEl) {
        statusEl.style.display = 'inline-block';
        statusEl.textContent = '';
        statusEl.classList.add('error');
        statusEl.classList.remove('success');
      }

      let errorDetails = document.getElementById('error-details');
      if (!errorDetails && spinnerContainer) {
        errorDetails = document.createElement('div');
        errorDetails.id = 'error-details';
        errorDetails.className = 'error-details';
        spinnerContainer.appendChild(errorDetails);
      }

      if (errorDetails) {
        // errorDetails.textContent = message; // This was causing issues, let animations handle it or remove.
        errorDetails.style.display = 'none'; // Keep this hidden, rely on class-based animation
      }
    }

    function showSuccess() {
      const statusEl = document.getElementById('status');
      if (statusEl) statusEl.textContent = 'Redirecting';

      if (isModalOpen) {
        pendingAction = 'success';
        // Do not add 'success' class or start animations yet
        return;
      }
      document.querySelector('.container').classList.add('success');
      // The redirect will be handled by submitSolution after a delay
    }

    function Verifier(params, targetPath, requestID) {
      const workers = [];
      const activeBatches = {};
      let powSolution = null;
      let isRunning = false;

      const cpuCount = navigator.hardwareConcurrency || 4;
      const workerCount = Math.max(1, Math.floor(cpuCount * 0.8));

      // const REDIRECT_DELAY = 1488; // Defined globally now

      this.start = function () {
        setTimeout(findProofOfWork, 100);
      };

      async function findProofOfWork() {
        try {
          isRunning = true;

          const challenge = params.a;
          const salt = params.b;
          const target = '0'.repeat(params.c);

          for (let i = 0; i < workerCount; i++) {
            const worker = createWorker();

            worker.onmessage = (e) => handleWorkerMessage(e.data);
            worker.onerror = (error) => {};
            workers.push(worker);
          }

          const totalRange = Number.MAX_SAFE_INTEGER;
          const rangePerWorker = Math.floor(totalRange / workerCount);

          for (let i = 0; i < workers.length; i++) {
            const startNonce = i * rangePerWorker;
            const endNonce = i === workers.length - 1 ? totalRange : (i + 1) * rangePerWorker - 1;

            const workerId = `pow-worker-${i}`;

            activeBatches[workerId] = {
              workerId: i,
              startNonce,
              endNonce,
            };

            workers[i].postMessage({
              type: 'pow',
              data: {
                challenge: challenge,
                salt: salt,
                startNonce,
                endNonce,
                target,
                batchId: workerId,
              },
            });
          }
        } catch (error) {
          terminateWorkers();
          showError(error.message);
        }
      }

      function handleWorkerMessage(data) {
        if (!isRunning) return;

        if (data.type === 'pow_result') {
          if (activeBatches[data.batchId]) {
            delete activeBatches[data.batchId];

            if (data.solution && data.solution.found) {
              if (!powSolution) {
                powSolution = data.solution;
                proofOfWorkFound(powSolution);
              }
            }
          }
        } else if (data.type === 'error') {
          showError('Compatibility error: ' + data.error);
          terminateWorkers();
        }
      }

      async function proofOfWorkFound(solution) {
        isRunning = false;
        terminateWorkers();
        try {
          const posResult = await new Promise((res) => {
            const w = createPosWorker();
            w.onmessage = (e) => {
              if (e.data.type === 'pos_result') {
                res(e.data);
                w.terminate();
              }
            };
            w.postMessage({ type: 'pos', seedHex: params.d, isDecoy: false });
          });

          await submitSolution({
            requestID,
            g: solution.nonce,
            h: posResult.hashes,
            i: posResult.times,
          });
        } catch (error) {
          showError(error.message);
        }
      }

      function terminateWorkers() {
        workers.forEach((worker) => worker.terminate());
      }

      async function submitSolution(solutionData) {
        try {
          const response = await fetch('/api/verify', {
            method: 'POST',
            credentials: 'include',
            headers: {
              'Content-Type': 'application/json',
            },
            body: JSON.stringify({
              request_id: solutionData.requestID,
              g: solutionData.g,
              h: solutionData.h,
              i: solutionData.i,
            }),
          });

          if (!response.ok) {
            let errorMsg = `Verification failed: ${response.statusText}`;
            try {
              const errorData = await response.json();
              if (errorData && errorData.error) {
                errorMsg += ` - ${errorData.error}`;
              } else {
                const text = await response.text();
                errorMsg += ` - Response: ${text}`;
              }
            } catch (parseError) {}
            showError(errorMsg);
            return;
          }

          let result;
          try {
            result = await response.json();
          } catch (e) {
            showError('Invalid verification response');
            return;
          }
          const token = result.token;
          if (!token) {
            // Use existing showError for immediate display if modal not involved
            // or to set up pending error if modal is open.
            showError('Verification did not return a token');
            return;
          }

          // Store for potential delayed redirect
          const sep = targetPath.includes('?') ? '&' : '?';
          storedRedirectUrl = `${targetPath}${sep}token=${encodeURIComponent(token)}`;

          showSuccess(); // This will now respect isModalOpen

          if (!isModalOpen) {
            setTimeout(() => {
              window.location.href = storedRedirectUrl;
            }, REDIRECT_DELAY);
          }
        } catch (error) {
          // Use existing showError
          showError('Verification failed. Please refresh the page.');
        }
      }
    }
  }
});