import { HttpService } from "@nestjs/axios";
import { InternalServerErrorException, Logger } from "@nestjs/common";
import { Injectable } from "@nestjs/common";
import { ConfigService } from "@nestjs/config";
import fontkit from "@pdf-lib/fontkit";
import { ResumeDto } from "@reactive-resume/dto";
import { getFontUrls, withTimeout } from "@reactive-resume/utils";
import retry from "async-retry";
import { PDFDocument } from "pdf-lib";
import { connect } from "puppeteer";

import { Config } from "../config/schema";
import { ErrorMessage } from "../constants/error-message";
import { StorageService } from "../storage/storage.service";
import { UtilsService } from "../utils/utils.service";

const PRINTER_TIMEOUT = 10000; // 10 seconds

@Injectable()
export class PrinterService {
  private readonly logger = new Logger(PrinterService.name);

  private browserEndpoint: string;

  constructor(
    private readonly configService: ConfigService<Config>,
    private readonly storageService: StorageService,
    private readonly httpService: HttpService,
    private readonly utils: UtilsService,
  ) {
    const chromeUrl = this.configService.getOrThrow<string>("CHROME_URL");
    const chromeToken = this.configService.getOrThrow<string>("CHROME_TOKEN");

    this.browserEndpoint = `${chromeUrl}?token=${chromeToken}`;
  }

  private getBrowser() {
    try {
      return connect({ browserWSEndpoint: this.browserEndpoint });
    } catch (error) {
      throw new InternalServerErrorException(ErrorMessage.InvalidBrowserConnection, error.message);
    }
  }

  async getVersion() {
    const browser = await this.getBrowser();
    const version = await browser.version();
    browser.disconnect();
    return version;
  }

  async printResume(resume: ResumeDto) {
    return this.utils.getCachedOrSet(
      `user:${resume.userId}:storage:resumes:${resume.id}`,
      async () => {
        const start = performance.now();

        const url = await retry(() => withTimeout(this.generateResume(resume), PRINTER_TIMEOUT), {
          retries: 3,
          randomize: true,
          onRetry: (_, attempt) => {
            this.logger.debug(`Retrying resume print job: Attempt #${attempt}`);
          },
        });

        const duration = Number(performance.now() - start).toFixed(0);
        const numPages = resume.data.metadata.layout.length;

        this.logger.debug(`Chrome took ${duration}ms to print ${numPages} page(s)`);

        return url;
      },
    );
  }

  async printPreview(resume: ResumeDto) {
    return this.utils.getCachedOrSet(
      `user:${resume.userId}:storage:previews:${resume.id}`,
      async () => {
        return withTimeout(this.generatePreview(resume), PRINTER_TIMEOUT);
      },
    );
  }

  async generateResume(resume: ResumeDto) {
    const browser = await this.getBrowser();

    const page = await browser.newPage();

    let url = this.utils.getUrl();
    const publicUrl = this.configService.getOrThrow<string>("PUBLIC_URL");
    const storageUrl = this.configService.getOrThrow<string>("STORAGE_URL");

    if ([publicUrl, storageUrl].some((url) => url.includes("localhost"))) {
      // Switch client URL from `localhost` to `host.docker.internal` in development
      // This is required because the browser is running in a container and the client is running on the host machine.
      url = url.replace("localhost", "host.docker.internal");

      await page.setRequestInterception(true);

      // Intercept requests of `localhost` to `host.docker.internal` in development
      page.on("request", (request) => {
        if (request.url().startsWith(storageUrl)) {
          const modifiedUrl = request.url().replace("localhost", `host.docker.internal`);

          request.continue({ url: modifiedUrl });
        } else {
          request.continue();
        }
      });
    }

    // Set the data of the resume to be printed in the browser's session storage
    const numPages = resume.data.metadata.layout.length;

    await page.evaluateOnNewDocument((data) => {
      sessionStorage.setItem("resume", JSON.stringify(data));
    }, resume.data);

    await page.goto(`${url}/artboard/preview`, { waitUntil: "networkidle0" });

    const pagesBuffer: Buffer[] = [];

    const processPage = async (index: number) => {
      const pageElement = await page.$(`[data-page="${index}"]`);
      const width = (await (await pageElement?.getProperty("scrollWidth"))?.jsonValue()) ?? 0;
      const height = (await (await pageElement?.getProperty("scrollHeight"))?.jsonValue()) ?? 0;

      const tempHtml = await page.evaluate((element: HTMLDivElement) => {
        const clonedElement = element.cloneNode(true) as HTMLDivElement;
        const tempHtml = document.body.innerHTML;
        document.body.innerHTML = `${clonedElement.outerHTML}`;
        return tempHtml;
      }, pageElement);

      pagesBuffer.push(await page.pdf({ width, height }));

      await page.evaluate((tempHtml: string) => {
        document.body.innerHTML = tempHtml;
      }, tempHtml);
    };

    // Loop through all the pages and print them, by first displaying them, printing the PDF and then hiding them back
    for (let index = 1; index <= numPages; index++) {
      await processPage(index);
    }

    // Using 'pdf-lib', merge all the pages from their buffers into a single PDF
    const pdf = await PDFDocument.create();
    pdf.registerFontkit(fontkit);

    // Get information about fonts used in the resume from the metadata
    const fontData = resume.data.metadata.typography.font;

    const fontUrls = getFontUrls(fontData.family, fontData.variants);

    // Load all the fonts from the URLs using HttpService
    const responses = await Promise.all(
      fontUrls.map((url) =>
        this.httpService.axiosRef.get(url, {
          responseType: "arraybuffer",
        }),
      ),
    );
    const fontsBuffer = responses.map((response) => response.data as ArrayBuffer);

    // Embed all the fonts in the PDF
    await Promise.all(fontsBuffer.map((buffer) => pdf.embedFont(buffer)));

    for (let index = 0; index < pagesBuffer.length; index++) {
      const page = await PDFDocument.load(pagesBuffer[index]);
      const copiedPage = await pdf.copyPages(page, [0]);
      pdf.addPage(copiedPage[0]);
    }

    // Save the PDF to storage and return the URL to download the resume
    // Store the URL in cache for future requests, under the previously generated hash digest
    const buffer = Buffer.from(await pdf.save());

    // This step will also save the resume URL in cache
    const resumeUrl = await this.storageService.uploadObject(
      resume.userId,
      "resumes",
      buffer,
      resume.id,
    );

    // Close all the pages and disconnect from the browser
    await page.close();
    browser.disconnect();

    return resumeUrl;
  }

  async generatePreview(resume: ResumeDto) {
    const browser = await this.getBrowser();

    const page = await browser.newPage();

    let url = this.utils.getUrl();
    const publicUrl = this.configService.getOrThrow<string>("PUBLIC_URL");
    const storageUrl = this.configService.getOrThrow<string>("STORAGE_URL");

    if ([publicUrl, storageUrl].some((url) => url.includes("localhost"))) {
      // Switch client URL from `localhost` to `host.docker.internal` in development
      // This is required because the browser is running in a container and the client is running on the host machine.
      url = url.replace("localhost", "host.docker.internal");

      await page.setRequestInterception(true);

      // Intercept requests of `localhost` to `host.docker.internal` in development
      page.on("request", (request) => {
        if (request.url().startsWith(storageUrl)) {
          const modifiedUrl = request.url().replace("localhost", `host.docker.internal`);

          request.continue({ url: modifiedUrl });
        } else {
          request.continue();
        }
      });
    }

    // Set the data of the resume to be printed in the browser's session storage
    await page.evaluateOnNewDocument((data: string) => {
      sessionStorage.setItem("resume", data);
    }, JSON.stringify(resume.data));

    await page.setViewport({ width: 794, height: 1123 });

    await page.goto(`${url}/artboard/preview`, { waitUntil: "networkidle0" });

    // Save the JPEG to storage and return the URL
    // Store the URL in cache for future requests, under the previously generated hash digest
    const buffer = await page.screenshot({ quality: 80, type: "jpeg" });

    // Generate a hash digest of the resume data, this hash will be used to check if the resume has been updated
    const previewUrl = await this.storageService.uploadObject(
      resume.userId,
      "previews",
      buffer,
      resume.id,
    );

    // Close all the pages and disconnect from the browser
    await page.close();
    browser.disconnect();

    return previewUrl;
  }
}