import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';
import { wasm } from '@rollup/plugin-wasm';
import inject from '@rollup/plugin-inject';
import { viteStaticCopy } from 'vite-plugin-static-copy';
import { vanillaExtractPlugin } from '@vanilla-extract/vite-plugin';
import { VitePWA } from 'vite-plugin-pwa';
import fs from 'fs';
import path from 'path';
import buildConfig from './build.config.ts';

const copyFiles = {
  targets: [
    {
      // Element Call's dist must land flat in public/element-call/ so the call
      // widget URL (/public/element-call/index.html) resolves. v4.x of
      // vite-plugin-static-copy preserves the full source path under dest, so
      // we strip the 4 leading segments of the source base
      // (node_modules/@lotusguild/element-call-embedded/dist) — mirroring the
      // stripBase pattern used by the android/locales targets below. The old
      // `rename: 'element-call'` form silently produced
      // public/node_modules/.../dist/ under v4.x, 404ing the widget (calls
      // broke on cinny-desktop; web only worked because its deployed copy was
      // a stale artifact from before the vite-plugin-static-copy v4 bump).
      // Source is our self-built fork (LotusGuild/element-call) published to
      // the Gitea npm registry; see HANDOFF_ELEMENT_CALL_FORK.md.
      src: 'node_modules/@lotusguild/element-call-embedded/dist',
      dest: 'public/element-call',
      rename: { stripBase: 4 },
    },
    {
      src: 'config.json',
      dest: '',
    },
    {
      src: 'public/manifest.json',
      dest: '',
      rename: { stripBase: true },
    },
    {
      // All of public/res/ (android + apple icons, logos, svg) → dist/public/res/,
      // matching the /public/res/... paths used by index.html and manifest.json.
      // (The old android-only target stripped `res/` and landed at /public/android/,
      // so every icon 404'd — apple/ + favicon weren't copied at all.)
      src: 'public/res',
      dest: 'public/',
      rename: { stripBase: 1 },
    },
    {
      src: 'public/favicon.ico',
      dest: 'public/',
      rename: { stripBase: 1 },
    },
    {
      src: 'public/locales',
      dest: 'public/',
      rename: { stripBase: 1 },
    },
    {
      src: 'public/fonts',
      dest: '',
      rename: { stripBase: 1 },
    },
  ],
};

function copyPdfWorker() {
  return {
    name: 'copy-pdf-worker',
    closeBundle() {
      // Never throw from here: closeBundle also runs when the build FAILED
      // mid-render (dist/ absent) and an exception here MASKS the real build
      // error in vite's report (seen on the Windows CI runner). Warn and skip.
      try {
        const src = path.resolve('node_modules/pdfjs-dist/build/pdf.worker.min.mjs');
        const dest = path.resolve('dist/pdf.worker.min.js');
        if (!fs.existsSync(src)) {
          console.warn('[copy-pdf-worker] source worker missing, skipped:', src);
          return;
        }
        fs.mkdirSync(path.dirname(dest), { recursive: true });
        fs.copyFileSync(src, dest);
      } catch (err) {
        console.warn('[copy-pdf-worker] skipped:', err?.message ?? err);
      }
    },
  };
}

// Lotus ML noise suppression: ship the RNNoise worklet/wasm + our getUserMedia
// shim alongside the vendored Element Call bundle, and inject the shim <script>
// into EC's index.html so it runs before EC captures the mic. Runs after
// viteStaticCopy has populated dist/public/element-call (closeBundle order).
function lotusDenoise() {
  return {
    name: 'lotus-denoise',
    closeBundle() {
      const ecDir = path.resolve('dist/public/element-call');
      if (!fs.existsSync(ecDir)) return;

      const denoiseDir = path.join(ecDir, 'denoise');
      fs.mkdirSync(denoiseDir, { recursive: true });

      const sapphi = path.resolve('node_modules/@sapphi-red/web-noise-suppressor/dist');
      // All bundled denoise assets are REQUIRED: every entry backs a model the
      // UI can select (RNNoise, Speex) or the optional noise gate. A missing
      // source means a partial/changed install would otherwise silently ship a
      // broken ML feature (worklet 404 -> raw mic), so we fail the build instead.
      const assets = [
        [
          path.join(sapphi, 'rnnoise/workletProcessor.js'),
          path.join(denoiseDir, 'rnnoiseWorklet.js'),
        ],
        [path.join(sapphi, 'rnnoise.wasm'), path.join(denoiseDir, 'rnnoise.wasm')],
        [path.join(sapphi, 'rnnoise_simd.wasm'), path.join(denoiseDir, 'rnnoise_simd.wasm')],
        [path.join(sapphi, 'speex/workletProcessor.js'), path.join(denoiseDir, 'speexWorklet.js')],
        [path.join(sapphi, 'speex.wasm'), path.join(denoiseDir, 'speex.wasm')],
        [
          path.join(sapphi, 'noiseGate/workletProcessor.js'),
          path.join(denoiseDir, 'noiseGateWorklet.js'),
        ],
      ];
      const missing = assets.filter(([s]) => !fs.existsSync(s)).map(([s]) => s);
      if (missing.length > 0) {
        throw new Error(
          `[lotus-denoise] Required denoise asset(s) missing — build aborted to avoid shipping a broken ML feature:\n  ${missing.join('\n  ')}`,
        );
      }
      assets.forEach(([s, d]) => fs.copyFileSync(s, d));

      // DTLN (@workadventure/noise-suppression): unlike the flat sapphi
      // worklets, this package is a self-contained ES module that resolves its
      // own AudioWorklet processor, LiteRT WASM runtime and TFLite models via
      // `import.meta.url`. So we copy its whole dist/ tree intact to
      // denoise/workadventure/ (preserving assets/ + vendor/) and let the shim
      // dynamic-import denoise/workadventure/audio-worklet.js at runtime. The
      // entry module is required — fail the build if the install is broken.
      const dtlnSrc = path.resolve('node_modules/@workadventure/noise-suppression/dist');
      const dtlnEntry = path.join(dtlnSrc, 'audio-worklet.js');
      if (!fs.existsSync(dtlnEntry)) {
        throw new Error(
          `[lotus-denoise] DTLN entry missing (${dtlnEntry}) — build aborted. ` +
            'Run `npm ci` to install @workadventure/noise-suppression.',
        );
      }
      fs.cpSync(dtlnSrc, path.join(denoiseDir, 'workadventure'), { recursive: true });

      // DeepFilterNet 3 (deepfilternet3-noise-filter): the npm package ships only
      // its ESM (index.esm.js) with the AudioWorklet processor + wasm-bindgen glue
      // INLINED as a string (loaded via a Blob URL, no CDN for the worklet). The
      // only runtime CDN fetches are its single-threaded `df_bg.wasm` and the
      // ONNX `DeepFilterNet3_onnx.tar.gz` model — which we VENDOR locally (under
      // build/denoise-vendor/deepfilternet/) and serve, overriding the package's
      // cdnUrl to our self-hosted base. This keeps the feature CDN-free / Tauri-CSP
      // safe. We copy the ESM (the shim dynamic-imports it, mirroring DTLN) plus
      // the vendored assets, preserving the package's expected v2/... layout. All
      // are required — a missing entry means a broken install, so fail the build.
      const dfnEsm = path.resolve('node_modules/deepfilternet3-noise-filter/dist/index.esm.js');
      const dfnVendor = path.resolve('build/denoise-vendor/deepfilternet');
      const dfnAssets = [
        [dfnEsm, path.join(denoiseDir, 'deepfilternet/index.esm.js')],
        [
          path.join(dfnVendor, 'v2/pkg/df_bg.wasm'),
          path.join(denoiseDir, 'deepfilternet/v2/pkg/df_bg.wasm'),
        ],
        [
          path.join(dfnVendor, 'v2/models/DeepFilterNet3_onnx.tar.gz'),
          path.join(denoiseDir, 'deepfilternet/v2/models/DeepFilterNet3_onnx.tar.gz'),
        ],
      ];
      const dfnMissing = dfnAssets.filter(([s]) => !fs.existsSync(s)).map(([s]) => s);
      if (dfnMissing.length > 0) {
        throw new Error(
          '[lotus-denoise] DeepFilterNet 3 asset(s) missing — build aborted to avoid ' +
            'shipping a broken ML feature:\n  ' +
            dfnMissing.join('\n  ') +
            '\n(Run `npm ci`; the vendored wasm/model live under build/denoise-vendor/deepfilternet/.)',
        );
      }
      dfnAssets.forEach(([s, d]) => {
        fs.mkdirSync(path.dirname(d), { recursive: true });
        fs.copyFileSync(s, d);
      });

      // [lotus] DENOISE CUTOVER: the getUserMedia shim is no longer injected.
      // Our forked Element Call now runs ML denoise in-source as a real LiveKit
      // audio TrackProcessor (activated by lotusDenoiseSource=1 in CallEmbed),
      // which survives reconnects (fixes A7). We still copy the denoise/ assets
      // above because the in-source processor loads its worklets/wasm from
      // ./denoise/ at runtime. To roll back to the shim: restore the
      // copy+inject of build/lotus-denoise.js here and swap lotusDenoiseSource
      // back to lotusDenoise=ml in CallEmbed.getWidget.
    },
  };
}

function serverMatrixSdkCryptoWasm(wasmFilePath) {
  return {
    name: 'vite-plugin-serve-matrix-sdk-crypto-wasm',
    configureServer(server) {
      server.middlewares.use((req, res, next) => {
        if (req.url === wasmFilePath) {
          const resolvedPath = path.join(
            path.resolve(),
            '/node_modules/@matrix-org/matrix-sdk-crypto-wasm/pkg/matrix_sdk_crypto_wasm_bg.wasm',
          );

          if (fs.existsSync(resolvedPath)) {
            res.setHeader('Content-Type', 'application/wasm');
            res.setHeader('Cache-Control', 'no-cache');

            const fileStream = fs.createReadStream(resolvedPath);
            fileStream.pipe(res);
          } else {
            res.writeHead(404);
            res.end('File not found');
          }
        } else {
          next();
        }
      });
    },
  };
}

const vendorChunks = (id) => {
  if (id.includes('node_modules/matrix-js-sdk')) return 'matrix-sdk';
  if (id.includes('node_modules/react-dom')) return 'react-dom';
  if (
    id.includes('node_modules/react-router') ||
    id.includes('node_modules/@remix-run') ||
    id.includes('node_modules/react-router/')
  )
    return 'router';
  if (id.includes('node_modules/@tanstack')) return 'react-query';
  if (id.includes('node_modules/linkify')) return 'linkify';
  if (id.includes('node_modules/dompurify')) return 'dompurify';
  if (id.includes('node_modules/@sentry')) return 'sentry';
  if (id.includes('node_modules/i18next') || id.includes('node_modules/react-i18next'))
    return 'i18n';
  if (id.includes('node_modules/jotai')) return 'jotai';
  if (id.includes('node_modules/immer')) return 'immer';
  if (id.includes('node_modules/folds')) return 'folds';
  if (id.includes('node_modules/emojibase')) return 'emojibase';
};

export default defineConfig({
  appType: 'spa',
  publicDir: './public/res',
  base: buildConfig.base,
  server: {
    port: 8080,
    host: true,
    fs: {
      allow: ['..'],
    },
  },
  plugins: [
    serverMatrixSdkCryptoWasm('/node_modules/.vite/deps/pkg/matrix_sdk_crypto_wasm_bg.wasm'),
    viteStaticCopy(copyFiles),
    vanillaExtractPlugin(),
    wasm(),
    react(),
    copyPdfWorker(),
    lotusDenoise(),
    VitePWA({
      srcDir: 'src',
      filename: 'sw.ts',
      strategies: 'injectManifest',
      injectRegister: false,
      manifest: false,
      injectManifest: {
        // PRECACHE (P5): emit `self.__WB_MANIFEST` into src/sw.ts so it can
        // precacheAndRoute the hashed build assets. index.html is deliberately
        // EXCLUDED from the manifest (globs only `assets/**`) so navigations
        // stay network-first and a new deploy is picked up immediately — see
        // the deploy-safety invariants documented in src/sw.ts.
        injectionPoint: 'self.__WB_MANIFEST',
        globPatterns: ['assets/**/*.{js,css,wasm}'],
        // Assets are content-hashed, so the filename is the cache key — don't
        // append a revision cache-busting param.
        dontCacheBustURLsMatching: /assets\//,
        // Raised above the 2 MB default so the ~5.5 MB matrix-sdk crypto wasm
        // (hash-busted and hot on every session) is precached deliberately.
        maximumFileSizeToCacheInBytes: 10 * 1024 * 1024,
        // codeSplitting: false is not yet supported by vite-plugin-pwa 1.3.0;
        // the inlineDynamicImports deprecation warning from Vite is from pwa internal build
      },
      devOptions: {
        enabled: true,
        type: 'module',
      },
    }),
  ],
  optimizeDeps: {
    define: {
      global: 'globalThis',
    },
  },
  build: {
    target: 'esnext',
    outDir: 'dist',
    sourcemap: false,
    copyPublicDir: false,
    // manualChunks must be in rolldownOptions (not rollupOptions) for Vite 8 / Rolldown
    rolldownOptions: {
      checks: { preferBuiltinFeature: false },
      output: {
        manualChunks: vendorChunks,
      },
    },
    rollupOptions: {
      plugins: [inject({ Buffer: ['buffer', 'Buffer'] })],
    },
  },
});
