const { Documenso } = require("@documenso/sdk-typescript");
const axios = require("axios");
const { jsrAuthString } = require("../utils/utils");
const logger = require("../utils/logger");
//Need to pull the key dynamically to send documents.
const JSR_SERVER = process.env.JSR_URL || "https://reports.imex.online";
const DOCUMENSO_SERVER_URL = process.env.DOCUMENSO_SERVER_URL || "https://sign.imex.online/api/v2";
const jsreport = require("@jsreport/nodejs-client");
const {
  QUERY_JOB_FOR_SIGNATURE,
  INSERT_ESIGNATURE_DOCUMENT,
  DISTRIBUTE_ESIGNATURE_DOCUMENT,
  QUERY_ESIGNATURE_BY_EXTERNAL_ID,
  UPDATE_ESIGNATURE_DOCUMENT,
  QUERY_DOCUMENSO_KEY,
  INSERT_ESIG_AUDIT_TRAIL
} = require("../graphql-client/queries");
const _ = require("lodash");

function parseJsonField(value, fallback = null) {
  if (value === undefined || value === null) {
    return fallback;
  }

  if (typeof value !== "string") {
    return value;
  }

  try {
    return JSON.parse(value);
  } catch {
    return fallback;
  }
}

function getDefaultEsignData({ esigData, bodyshop, fileName }) {
  const fallbackTitle = fileName || `Esign request from ${bodyshop.shopname}`;

  return {
    ...esigData,
    title: esigData?.title || fallbackTitle,
    subject: esigData?.subject || `Esign request from ${bodyshop.shopname}`,
    message: esigData?.message || `Please review and sign the document from ${bodyshop.shopname}.`
  };
}

function createClientError(message, statusCode = 400) {
  const error = new Error(message);
  error.statusCode = statusCode;
  return error;
}

function isValidEmail(email) {
  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
}

function getJobOwnerName(jobData, email) {
  const ownerName = [jobData?.ownr_fn, jobData?.ownr_ln].filter(Boolean).join(" ").trim();
  return ownerName || jobData?.ownr_co_nm || email;
}

function getJobOwnerRecipients(jobData) {
  const ownerEmail = jobData?.ownr_ea?.trim();

  if (!ownerEmail) {
    throw createClientError("Job owner email is required before sending an e-signature request.");
  }

  if (!isValidEmail(ownerEmail)) {
    throw createClientError(`Job owner email "${ownerEmail}" is not valid.`);
  }

  return [
    {
      email: ownerEmail,
      name: getJobOwnerName(jobData, ownerEmail),
      role: "SIGNER"
    }
  ];
}

async function getDocumensoClient({ bodyshopid, req }) {
  const { apiKey } = await getDocumensoConfig({ bodyshopid, req });
  return new Documenso({
    apiKey,
    serverURL: DOCUMENSO_SERVER_URL
  });
}

async function getDocumensoConfig({ bodyshopid, req }) {
  const client = req.userGraphQLClient;
  const {
    bodyshops_by_pk: { documenso_api_key }
  } = await client.request(QUERY_DOCUMENSO_KEY, { bodyshopid });

  return {
    apiKey: documenso_api_key,
    serverURL: DOCUMENSO_SERVER_URL
  };
}

async function getDocumensoDocument({ apiKey, documentId }) {
  const { data } = await axios.get(`${DOCUMENSO_SERVER_URL}/document/${encodeURIComponent(documentId)}`, {
    headers: {
      Accept: "application/json",
      Authorization: apiKey
    }
  });

  return data;
}

async function createEsignDocumentFromPdf({ req, bodyshop, pdfBuffer, esigData, fileName }) {
  const resolvedEsigData = getDefaultEsignData({ esigData, bodyshop, fileName });
  const fileBlob = new Blob([pdfBuffer], { type: "application/pdf" });
  const jobid = req.body.jobid;
  const client = req.userGraphQLClient;

  const { jobs_by_pk: jobData } = await client.request(QUERY_JOB_FOR_SIGNATURE, { jobid });
  const recipients = getJobOwnerRecipients(jobData);

  const documensoConfig = await getDocumensoConfig({ bodyshopid: bodyshop.id, req });
  const documenso = new Documenso({
    apiKey: documensoConfig.apiKey,
    serverURL: documensoConfig.serverURL
  });

  const createDocumentResponse = await documenso.documents.create({
    payload: {
      title: resolvedEsigData.title,
      externalId: `${jobid}|${req.user?.email}`,
      recipients,
      meta: {
        timezone: bodyshop.timezone,
        dateFormat: "MM/dd/yyyy hh:mm a",
        language: "en",
        subject: resolvedEsigData.subject,
        message: resolvedEsigData.message
      }
    },
    file: fileBlob
  });

  const documentResult = await getDocumensoDocument({
    apiKey: documensoConfig.apiKey,
    documentId: createDocumentResponse.id
  });

  if (resolvedEsigData?.fields && resolvedEsigData.fields.length > 0) {
    try {
      await documenso.envelopes.fields.createMany({
        envelopeId: createDocumentResponse.envelopeId,
        data: resolvedEsigData.fields.map((sigField) => ({ ...sigField, recipientId: documentResult.recipients[0].id }))
      });
    } catch (error) {
      logger.log(`esig-new-fields-error`, "ERROR", "esig", "api", {
        message: error.message,
        stack: error.stack,
        body: req.body
      });
    }
  }

  const presignToken = await documenso.embedding.embeddingPresignCreateEmbeddingPresignToken({});

  await client.request(INSERT_ESIGNATURE_DOCUMENT, {
    audit: {
      jobid,
      bodyshopid: bodyshop.id,
      operation: `Esignature document created. Subject: ${resolvedEsigData.subject || "No subject"}, Message: ${resolvedEsigData.message || "No message"}. Document ID: ${createDocumentResponse.id} Envlope ID: ${createDocumentResponse.envelopeId}`,
      useremail: req.user?.email,
      type: "esig-create"
    },
    esig: {
      jobid,
      external_document_id: createDocumentResponse.id.toString(),
      subject: resolvedEsigData.subject || "No subject",
      message: resolvedEsigData.message || "No message",
      title: resolvedEsigData.title || "No title",
      status: "DRAFT",
      recipients: recipients
    }
  });

  return {
    token: presignToken.token,
    documentId: createDocumentResponse.id,
    envelopeId: createDocumentResponse.envelopeId
  };
}

async function distributeDocument(req, res) {
  try {
    const client = req.userGraphQLClient;

    const { documentId, bodyshopid } = req.body;
    const documenso = await getDocumensoClient({ bodyshopid, req });

    const distributeResult = await documenso.documents.distribute({
      documentId
    });

    await client.request(DISTRIBUTE_ESIGNATURE_DOCUMENT, {
      external_document_id: documentId.toString(),
      esig_update: {
        status: "SENT"
      },
      audit: {
        jobid: req.body.jobid,
        bodyshopid: req.body.bodyshopid,
        operation: `Esignature document with title ${distributeResult.title} (ID: ${documentId}) distributed to recipients.`,
        useremail: req.user?.email,
        type: "esig-distribute"
      }
    });

    res.json({ success: true, distributeResult });
  } catch (error) {
    logger.log(`esig-distribute-error`, "ERROR", "esig", "api", {
      message: error.message,
      stack: error.stack,
      body: req.body
    });
    res.status(500).json({ error: "An error occurred while distributing the document.", message: error.message });
  }
}

async function redistributeDocument(req, res) {
  try {
    const client = req.userGraphQLClient;

    const { documentId, bodyshopid } = req.body;
    const documensoConfig = await getDocumensoConfig({ bodyshopid, req });
    const documenso = new Documenso({
      apiKey: documensoConfig.apiKey,
      serverURL: documensoConfig.serverURL
    });

    const document = await getDocumensoDocument({
      apiKey: documensoConfig.apiKey,
      documentId: parseInt(documentId)
    });

    const distributeResult = await documenso.documents.redistribute({
      documentId: parseInt(documentId),
      recipients: document.recipients.filter((r) => r.signingStatus === "NOT_SIGNED").map((r) => r.id)
    });

    await client.request(INSERT_ESIG_AUDIT_TRAIL, {
      obj: {
        jobid: req.body.jobid,
        bodyshopid: req.body.bodyshopid,
        operation: `Esignature document with title ${distributeResult.title} (ID: ${documentId}) redistributed to recipients.`,
        useremail: req.user?.email,
        type: "esig-redistribute"
      }
    });

    res.json({ success: true, distributeResult });
  } catch (error) {
    logger.log(`esig-redistribute-error`, "ERROR", "esig", "api", {
      message: error.message,
      stack: error.stack,
      body: req.body
    });
    res.status(500).json({ error: "An error occurred while redistributing the document.", message: error.message });
  }
}

async function deleteDocument(req, res) {
  try {
    const client = req.userGraphQLClient;

    const { documentId, bodyshopid } = req.body;
    const { esignature_documents } = await client.request(QUERY_ESIGNATURE_BY_EXTERNAL_ID, {
      external_document_id: documentId.toString()
    });

    if (!esignature_documents || esignature_documents.length === 0) {
      //return res.status(404).json({ error: "Document not found" });
    }
    const documenso = await getDocumensoClient({ bodyshopid, req });

    const deleteResult = await documenso.documents.delete({
      documentId: documentId
    });

    await client.request(UPDATE_ESIGNATURE_DOCUMENT, {
      external_document_id: documentId.toString(),
      esig_update: {
        status: "DELETED"
      }
    });
    res.json({ success: true, deleteResult });
  } catch (error) {
    logger.log(`esig-delete-error`, "ERROR", "esig", "api", {
      message: error.message,
      stack: error.stack,
      body: req.body
    });
    res.status(500).json({ error: "An error occurred while deleting the document." });
  }
}

async function viewDocument(req, res) {
  try {
    const { documentId, bodyshopid } = req.body;
    const documenso = await getDocumensoClient({ bodyshopid, req });

    const document = await documenso.document.documentDownload({
      documentId: parseInt(documentId)
    });
    res.json({ success: true, document });
  } catch (error) {
    logger.log(`esig-view-error`, "ERROR", "esig", "api", {
      message: error.message,
      stack: error.stack,
      body: req.body
    });
    res.status(500).json({ error: "An error occurred while retrieving the document.", message: error.message });
  }
}

async function newEsignDocument(req, res) {
  try {
    const client = req.userGraphQLClient;
    const { bodyshop } = req.body;
    const { pdf: fileBuffer, esigData } = await RenderTemplate({ client, req });
    const result = await createEsignDocumentFromPdf({
      req,
      bodyshop,
      pdfBuffer: fileBuffer,
      esigData
    });

    res.json(result);
  } catch (error) {
    logger.log(`esig-new-error`, "ERROR", "esig", "api", {
      message: error.message,
      stack: error.stack,
      body: _.omit(req.body, ["bodyshop"]) // bodyshop can be large, so we omit it from the logs
    });
    res
      .status(error.statusCode || 500)
      .json({ error: "An error occurred while creating the e-sign document.", message: error.message });
  }
}

async function newCustomEsignDocument(req, res) {
  try {
    const bodyshop = parseJsonField(req.body.bodyshop, req.body.bodyshop);
    const esigData = parseJsonField(req.body.esigData, {});
    const uploadedDocument = req.file;

    if (!uploadedDocument?.buffer) {
      return res.status(400).json({ error: "A PDF document is required." });
    }

    if (uploadedDocument.mimetype !== "application/pdf") {
      return res.status(400).json({ error: "Only PDF documents can be used for e-signature." });
    }

    req.body.bodyshop = bodyshop;

    const fileName = uploadedDocument.originalname?.replace(/\.[^.]+$/, "") || undefined;
    const result = await createEsignDocumentFromPdf({
      req,
      bodyshop,
      pdfBuffer: uploadedDocument.buffer,
      esigData,
      fileName
    });
    res.json(result);
  } catch (error) {
    logger.log(`esig-new-custom-error`, "ERROR", "esig", "api", {
      message: error.message,
      stack: error.stack,
      body: _.omit(req.body, ["bodyshop"]) // bodyshop can be large, so we omit it from the logs
    });
    res
      .status(error.statusCode || 500)
      .json({ error: "An error occurred while creating the custom e-sign document.", message: error.message });
  }
}

async function RenderTemplate({ req }) {
  const jsrAuth = jsrAuthString();
  const jsreportClient = new jsreport(JSR_SERVER, process.env.JSR_USER, process.env.JSR_PASSWORD);
  const { templateObject, bodyshop } = req.body;
  let { contextData, useShopSpecificTemplate, shopSpecificFolder, esigData } = await fetchContextData({
    templateObject,
    jsrAuth,
    req
  });

  const { ignoreCustomMargins } = { ignoreCustomMargins: false }; //  Templates[templateObject.name];
  let reportRequest = {
    template: {
      name: useShopSpecificTemplate ? `/${bodyshop.imexshopid}/${templateObject.name}` : `/${templateObject.name}`,

      recipe: "chrome-pdf",
      ...(!ignoreCustomMargins && {
        chrome: {
          marginTop:
            bodyshop.logo_img_path && bodyshop.logo_img_path.headerMargin && bodyshop.logo_img_path.headerMargin > 36
              ? bodyshop.logo_img_path.headerMargin
              : "36px",
          marginBottom:
            bodyshop.logo_img_path && bodyshop.logo_img_path.footerMargin && bodyshop.logo_img_path.footerMargin > 50
              ? bodyshop.logo_img_path.footerMargin
              : "50px"
        }
      })
    },
    data: {
      ...contextData,
      ...templateObject.variables,
      ...templateObject.context,
      headerpath: shopSpecificFolder ? `/${bodyshop.imexshopid}/header.html` : `/GENERIC/header.html`,
      footerpath: shopSpecificFolder ? `/${bodyshop.imexshopid}/footer.html` : `/GENERIC/footer.html`,
      bodyshop: bodyshop,
      esignature: true,
      filters: templateObject?.filters,
      sorters: templateObject?.sorters,
      offset: bodyshop.timezone, //dayjs().utcOffset(),
      defaultSorters: templateObject?.defaultSorters
    }
  };
  const render = await jsreportClient.render(reportRequest);

  //Check render object and download. It should be the PDF?
  const pdfBuffer = await render.body();
  return { pdf: pdfBuffer, esigData };
}

const fetchContextData = async ({ templateObject, jsrAuth, req }) => {
  const { bodyshop } = req.body;

  const folders = await axios.get(`${JSR_SERVER}/odata/folders`, {
    headers: { Authorization: jsrAuth }
  });
  const shopSpecificFolder = folders.data.value.find((f) => f.name === bodyshop.imexshopid);

  const jsReportQueries = await axios.get(`${JSR_SERVER}/odata/assets?$filter=name eq '${templateObject.name}.query'`, {
    headers: { Authorization: jsrAuth }
  });
  const jsReportEsig = await axios.get(`${JSR_SERVER}/odata/assets?$filter=name eq '${templateObject.name}.esig'`, {
    headers: { Authorization: jsrAuth }
  });

  let templateQueryToExecute;
  let esigData;
  let useShopSpecificTemplate = false;
  // let shopSpecificTemplate;

  if (shopSpecificFolder) {
    let shopSpecificTemplate = jsReportQueries.data.value.find(
      (f) => f?.folder?.shortid === shopSpecificFolder.shortid
    );
    if (shopSpecificTemplate) {
      useShopSpecificTemplate = true;
      templateQueryToExecute = atob(shopSpecificTemplate.content);
    }
    let shopSpecificEsig = jsReportEsig.data.value.find((f) => f?.folder?.shortid === shopSpecificFolder.shortid);
    if (shopSpecificEsig) {
      esigData = atob(shopSpecificEsig.content);
    }
  }

  if (!templateQueryToExecute) {
    const generalTemplate = jsReportQueries.data.value.find((f) => !f.folder);
    useShopSpecificTemplate = false;
    templateQueryToExecute = atob(generalTemplate.content);
  }
  if (!esigData) {
    const generalTemplate = jsReportEsig.data.value.find((f) => !f.folder);
    useShopSpecificTemplate = false;
    if (generalTemplate && generalTemplate.content) {
      esigData = atob(generalTemplate?.content);
    }
  }

  const client = req.userGraphQLClient;

  // In the print center, we will never have sorters or filters.
  // We have no template filters or sorters, so we can just execute the query and return the data
  //  if (!hasFilters && !hasSorters && !hasDefaultSorters) {
  let contextData = {};
  if (templateQueryToExecute) {
    const data = await client.request(templateQueryToExecute, templateObject.variables);
    contextData = data;
  }

  let parsedEsigData;
  try {
    parsedEsigData = esigData ? JSON.parse(esigData) : null;
  } catch (error) {
    logger.log(`esig-data-parse-error`, "ERROR", "esig", "api", {
      message: error.message,
      stack: error.stack,
      esigData,
      body: req.body
    });
    parsedEsigData = {};
  }

  return {
    contextData,
    useShopSpecificTemplate,
    shopSpecificFolder,
    esigData: parsedEsigData
  };
  //  }

  // return await generateTemplate(templateQueryToExecute, templateObject, useShopSpecificTemplate, shopSpecificFolder);
};

module.exports = {
  newEsignDocument,
  newCustomEsignDocument,
  distributeDocument,
  redistributeDocument,
  deleteDocument,
  viewDocument,
  getDocumensoClient
};