/* eslint-env node */

import {
  app,
  session,
  BrowserWindow,
  ipcMain,
  protocol,
  screen,
  shell,
} from "electron";

import path from "path";
import fs from "fs";

import { ArchiveRequest, ArchiveResponse, Rewriter } from "@webrecorder/wabac";

import { Readable } from "stream";

import { autoUpdater } from "electron-updater";
import log from "electron-log";

import mime from "mime-types";
import url from "url";

import minimist from "minimist";

//global.Headers = Headers;
//global.fetch = fetch;

const STATIC_PREFIX = "http://localhost:5471/";

const REPLAY_PREFIX = STATIC_PREFIX + "w/";

const FILE_PROTO = "file2";

const URL_RX = /([^/]+)\/([\d]+)(?:\w\w_)?\/(.*)$/;

// ============================================================================
class ElectronReplayApp {
  pluginPath = "";

  appPath = app.getAppPath();

  projPath = path.join(this.appPath, "../");

  staticContentPath = "./";

  profileName = "";

  proxyColl: string | null = null;

  proxyTS: string | null = null;

  mainWindow: BrowserWindow | null = null;

  openNextFile: string | null = null;

  screenSize = { width: 1024, height: 768 };

  origUA: string | null = null;

  constructor({ staticPath = "./", profileName = "" } = {}) {
    this.staticContentPath = staticPath;
    this.profileName = profileName;
  }

  get mainWindowWebPreferences() {
    return {
      plugins: true,
      preload: path.join(__dirname, "preload.js"),
      nativeWindowOpen: true,
      contextIsolation: true,
      enableRemoteModule: false,
      sandbox: false,
      nodeIntegration: false,
    };
  }

  get mainWindowUrl() {
    return "index.html";
  }

  init() {
    // Single instance check
    const gotTheLock = app.requestSingleInstanceLock();

    if (!gotTheLock) {
      console.log(
        "App already running, opening new window in first instance and quitting",
      );
      app.quit();
    } else {
      app.on("second-instance", (_, commandLine) => {
        // Just create a new window in case of second instance request
        this.createMainWindow(commandLine);
      });
    }

    console.log("app path", this.appPath);
    console.log("dir name", __dirname);
    console.log("proj path", this.projPath);

    console.log("app data", app.getPath("appData"));
    console.log("user data", app.getPath("userData"));

    // possible workaround for GTK issue on Linux
    // https://github.com/webrecorder/replayweb.page/issues/430
    // https://github.com/electron/electron/issues/46538#issuecomment-2808806722
    if (process.env.APPIMAGE) {
      app.commandLine.appendSwitch("--gtk-version", "3");
    }

    if (this.profileName) {
      app.setPath(
        "userData",
        path.join(app.getPath("appData"), this.profileName),
      );
    }

    protocol.registerSchemesAsPrivileged([
      {
        scheme: FILE_PROTO,
        privileges: {
          standard: false,
          secure: true,
          bypassCSP: true,
          allowServiceWorkers: true,
          supportFetchAPI: true,
          corsEnabled: true,
          stream: true,
        },
      },
    ]);

    app.on("will-finish-launching", () => {
      app.on("open-file", (event, filePath) => {
        this.openNextFile = filePath;
        if (this.mainWindow) {
          this.createMainWindow(process.argv);
        }
      });
    });

    app.on("activate", () => {
      // On macOS it's common to re-create a window in the app when the
      // dock icon is clicked and there are no other windows open.
      if (BrowserWindow.getAllWindows().length === 0) {
        this.mainWindow = this.createMainWindow(process.argv);
      }
    });

    void app.whenReady().then(() => this.onAppReady());

    // Quit when all windows are closed.
    app.on("window-all-closed", function () {
      // On macOS it is common for applications and their menu bar
      // to stay active until the user quits explicitly with Cmd + Q
      //if (process.platform !== 'darwin')
      app.quit();
    });
  }

  checkUpdates() {
    autoUpdater.logger = log;
    // @ts-expect-error - TS2339 - Property 'transports' does not exist on type 'Logger'.
    autoUpdater.logger.transports.file.level = "info";
    void autoUpdater.checkForUpdatesAndNotify();
  }

  onAppReady() {
    this.checkUpdates();

    this.screenSize = screen.getPrimaryDisplay().workAreaSize;

    app.on("web-contents-created", (event, contents) => {
      contents.setWindowOpenHandler(({ url }) => {
        // load docs in native browser for now
        if (url === STATIC_PREFIX + "docs") {
          void shell.openExternal("https://replayweb.page/docs/");
          return { action: "deny" };
        }

        // load external URLs in native browser
        if (!url.startsWith(STATIC_PREFIX)) {
          void shell.openExternal(url);
          return { action: "deny" };
        }

        return { action: "allow" };
      });
    });

    const sesh = session.defaultSession;

    sesh.protocol.handle("http", async (request: Request) =>
      this.doIntercept(request),
    );

    protocol.handle(FILE_PROTO, async (request: Request) =>
      this.doHandleFile(request),
    );

    this.origUA = sesh.getUserAgent();

    this.mainWindow = this.createMainWindow(process.argv);
  }

  async doHandleFile(request: Request): Promise<Response> {
    //const parsedUrl = new URL(request.url);
    //const filename = parsedUrl.searchParams.get("filename");

    if (request.url === FILE_PROTO + "://localhost") {
      return new Response("", { status: 200 });
    }

    let urlStr = request.url.replace(FILE_PROTO, "file");
    if (path.sep !== "/") {
      urlStr = urlStr.replace(/(\/\/\w)(\/\/)/, "$1:/");
      urlStr = urlStr.replaceAll("/", path.sep);
    }

    const filename = url.fileURLToPath(urlStr);

    const headers = new Headers({ "Content-Type": "application/octet-stream" });
    const reqHeaders = new Headers(request.headers);

    if (filename) {
      const stat = await fs.promises.lstat(filename);

      if (!stat.isFile()) {
        return this.notFound(filename);
      }

      const size = stat.size;

      const { status, start, end } = this.parseRange(reqHeaders, headers, size);

      const data =
        request.method === "HEAD"
          ? null
          : Readable.toWeb(fs.createReadStream(filename, { start, end }));

      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
      return new Response(data as any, { status, headers });
    } else {
      return this.notFound("No Resource Specified");
    }
  }

  async doIntercept(request: Request): Promise<Response> {
    console.log(`${request.method} ${request.url} from ${request.referrer}`);

    // if local server
    if (request.url.startsWith(STATIC_PREFIX)) {
      //if replay prefix
      if (request.url.startsWith(REPLAY_PREFIX)) {
        const m = request.url.slice(REPLAY_PREFIX.length).match(URL_RX);
        if (m) {
          this.proxyColl = m[1];
          this.proxyTS = m[2];

          //request.url = m[3];
          return await this.resolveArchiveResponse(request, m[3]);
        }
      } else {
        // try serve static file from app dir
        let filename = request.url.slice(STATIC_PREFIX.length).split("?", 1)[0];
        filename = filename.split("#", 1)[0];

        if (filename === "") {
          filename = "index.html";
        } else if (filename === "docs") {
          filename = "docs/index.html";
        }

        let ext = path.extname(filename);
        if (!ext) {
          ext = ".html";
          filename += ext;
        }

        const mimeType = mime.contentType(ext);

        if (mimeType) {
          const fullPath = path.join(this.staticContentPath, filename);

          console.log("fullPath: " + fullPath);

          const data = fs.createReadStream(fullPath);

          // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
          return new Response(Readable.toWeb(data) as any, {
            headers: { "content-type": mimeType },
            status: 200,
          });
        }
      }

      return this.notFound(request.url);
    }

    // possible 'live leak' attempt, return archived version, if any
    if (request.referrer.startsWith(REPLAY_PREFIX)) {
      return await this.resolveArchiveResponse(request);
    }

    return await this.proxyLive(request);
  }

  async proxyLive(request: Request): Promise<Response> {
    let headers = request.headers;
    const { method, url, body } = request;

    // const body = uploadData
    //   ? Readable.from(readBody(uploadData, session.defaultSession))
    //   : null;

    if (this.origUA) {
      headers = new Headers(headers);
      headers.set("User-Agent", this.origUA);
    }

    let response;

    try {
      response = await fetch(url, { method, headers, body });
    } catch (e) {
      console.warn("fetch failed for: " + url);
      return new Response("", { status: 502 });
    }
    const data = method === "HEAD" ? null : response.body;
    const status = response.status;

    return new Response(data, { status, headers: response.headers });
  }

  notFound(url: string) {
    console.log("not found: " + url);
    const headers = { "Content-Type": 'text/html; charset="utf-8"' };
    return new Response(
      `Sorry, the url <b>${url}</b> could not be found in this archive.`,
      { status: 404, headers },
    );
  }

  async resolveArchiveResponse(
    request: Request,
    urlOverride?: string,
  ): Promise<Response> {
    const url = urlOverride || request.url;
    const channel = `req:${new Date().getTime()}:${url}`;

    let resolve: (r: Response) => void;

    const p = new Promise<Response>((r) => (resolve = r));
    ipcMain.once(
      channel,
      async (
        event,
        status: number,
        reqHeaders: Record<string, string>,
        payload,
      ) => {
        if (status === 404 && !payload) {
          return this.notFound(url);
        } else {
          console.log("got response for: " + url);
        }

        let headers = new Headers(reqHeaders);
        const date = new Date();

        let response: ArchiveResponse = new ArchiveResponse({
          payload,
          headers,
          status,
          date,
          url,
        });

        const rewriter = new Rewriter({
          baseUrl: url,
          prefix: "",
          urlRewrite: false,
          contentRewrite: true,
          decode: true,
          useBaseRules: true,
        });

        const arRequest = new ArchiveRequest(url, request);

        try {
          response = await rewriter.rewrite(response, arRequest);

          headers = response.headers;

          let data = await response.getBuffer();
          if (!data) {
            data = new Uint8Array();
          }

          if (status === 206 || status === 200) {
            headers = new Headers(response.headers);
            const res = this.parseRange(request.headers, headers, data.length);
            const { start, end } = res;
            status = res.status;
            if (start !== undefined) {
              data = data.slice(start, end);
            }
          }

          resolve(new Response(data, { status, headers }));
        } catch (e) {
          console.warn(e);
        }
      },
    );

    if (this.mainWindow) {
      this.mainWindow.webContents.send(
        "getresponse",
        request,
        this.proxyColl,
        this.proxyTS,
        channel,
      );
    }

    return p;
  }

  parseRange(reqHeaders: Headers, headers: Headers, size: number) {
    let status = 200;
    const range = reqHeaders.get("range");

    if (!range) {
      headers.set("content-length", "" + size);
      return { status };
    }

    const m = range.match(/bytes=([\d]+)-([\d]*)/);
    if (!m) {
      return { status };
    }

    const start = Number(m[1]);
    const end = m[2] ? Number(m[2]) : size - 1;
    status = 206;
    headers.set("content-range", `bytes ${start}-${end}/${size}`);
    headers.set("content-length", `${end - start + 1}`);
    return { status, start, end };
  }

  createMainWindow(argv: string[]) {
    const sourceString = this.getOpenUrl(argv);

    // Create the browser window.
    const theWindow = new BrowserWindow({
      width: this.screenSize.width,
      height: this.screenSize.height,
      show: false,
      webPreferences: this.mainWindowWebPreferences,
    }).once("ready-to-show", () => {
      theWindow.show();
      theWindow.maximize();
    });

    void theWindow.loadURL(STATIC_PREFIX + this.mainWindowUrl + sourceString);
    if (process.env.NODE_ENV === "development") {
      theWindow.webContents.openDevTools();
    }

    return theWindow;
  }

  getOpenUrl(argv: string[]) {
    const parsed = minimist(argv.slice(process.defaultApp ? 2 : 1));

    const filename =
      this.openNextFile ||
      parsed.filename ||
      parsed.f ||
      (parsed._.length && parsed._[0]);

    this.openNextFile = null;

    let sourceString = "";

    if (filename) {
      const sourceParams = new URLSearchParams();
      sourceParams.set("source", "file://" + filename);
      sourceString = "?" + sourceParams.toString();

      const urlParams = new URLSearchParams();

      const openUrl = parsed.url as string | undefined;

      const openTS = (parsed.ts || parsed.timestamp) as string | undefined;

      if (openUrl) {
        urlParams.set("url", openUrl);
      }

      if (openTS) {
        urlParams.set("ts", openTS);
      }

      sourceString += "#" + urlParams.toString();

      console.log(`Opening Source: ${sourceString}`);
    }

    return sourceString;
  }
}

// async function* readBody(body, session) {
//   for (const chunk of body) {
//     if (chunk.bytes) {
//       yield await Promise.resolve(chunk.bytes);
//     } else if (chunk.blobUUID) {
//       yield await session.getBlobData(chunk.blobUUID);
//     }
//   }
// }

export { ElectronReplayApp, STATIC_PREFIX };