import {
    BadRequestException,
    InternalServerErrorException,
    Logger,
} from '@nestjs/common';
import * as oracledb from 'oracledb';

const PDFDocument = require('pdfkit');
const fs = require('fs');
const path = require('path');
import { PDFDocument as pdfl } from 'pdf-lib';
import PDFMerger from 'pdf-merger-js';
import * as fsPromises from 'fs/promises';
import { BadRequestException as BR } from 'src/exceptions/badRequest.exception';

const doc = new PDFDocument({
    size: 'A4',
    margins: {
        top: 50,
        bottom: 50,
        left: 50,
        right: 50
    }
});

const logger = new Logger('Helper');

export const handleError = (error: any, context: string = 'UnknownService'): never => {
    if (error instanceof BadRequestException || error instanceof BR) {
        logger.warn(`[${context}] ${error.message}`);
        throw error;
    }

    if (error.message?.includes('NJS-107')) {
        logger.warn(`[${context}] Invalid cursor encountered: ${error.message}`);
        throw new BadRequestException('Invalid database response.');
    }

    if (error.message?.includes('ORA-')) {
        logger.error(`[${context}] Oracle error occurred: ${error.message}`);
        throw new InternalServerErrorException(error.message);
    }

    logger.error(`[${context}] Unexpected error:`, error.stack || error);
    throw new InternalServerErrorException(error.message || 'Internal error');
};

export const closeOracleDbConnection = async (connection: any, context: string = 'UnknownService'): Promise<void> => {
    if (connection) {
        try {
            await connection.close();
        } catch (closeErr) {
            logger.error(`[${context}] Failed to close DB connection`, closeErr.stack || closeErr);
        }
    }
};

export const fetchCursor = async <T>(cursor: oracledb.ResultSet<T>, context: string = 'UnknownService'): Promise<T[]> => {
    try {
        const rows = await cursor.getRows();
        await cursor.close();
        return rows;
    } catch (err) {
        logger.error(`[${context}] Failed to fetch from cursor`, err.stack || err);
        throw new InternalServerErrorException('Error reading data from database.');
    }
};

export const setEmptyStringsToNull = (obj: any): void => {
    Object.keys(obj).forEach((key) => {
        if (typeof obj[key] === 'object' && obj[key] !== null) {
            setEmptyStringsToNull(obj[key]);
        } else if (obj[key] === '') {
            obj[key] = null;
        }
    });
}

export interface pdfGLData {
    itemNo: number;
    description: string;
    noOfPieces: number;
    weight: string;
    itemValue: number;
    countryOfOrigin: string
}

export interface pdfCarnetData {
    carnetNo: string;
    contPageNo: number;
}

function formatNumber(num) {
    if (isNaN(num)) return 'N/A';
    return num.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 });
}

export const generateGeneralistPDF1 = async (jsonData: pdfGLData[], headerData: pdfCarnetData) => {
    // --- Table Configuration ---
    const table = {
        x: doc.x,
        y: doc.y + 20, // Start a bit below the current cursor
        cellTopPadding: 5,
        cellBottomPadding: 2,
        cellHorizontalPadding: 5,
        cellSpacing: 0,
        headerColor: '#FFFFFF',
        rowColor: '#FFFFFF',
        alternatingRowColor: '#FFFFFF',
        lineColor: '#000000',
        headerFontColor: '#000000',
        bodyFontColor: '#000000',
        fontSize: 10,
        headerFontSize: 10,
        lineWidth: 0.5,
        widths: [50, 120, 70, 80, 70, 100], // 
        totalRowPaddingTop: 10 // New padding for the total row
    };

    // Define the maximum number of lines for the entire page
    const maxLinesPerPage = 37;
    const fixedHeaderRowHeight = 22;     // You can tweak this value
    const fixedHeaderFontSize = 10;      // Same font size for all rows


    // Fixed header rows, which are not part of the dynamic data
    function getFixedHeaderData(headerValues) {
        return [
            {
                isMergedRow: true,
                cols: [
                    { text: 'General List', startCol: 0, endCol: 5, }
                ]
            },
            {
                isMergedRow: true,
                cols: [
                    { text: '', startCol: 0, endCol: 2 },
                    { text: 'Carnet No:', startCol: 3, endCol: 4 },
                    { text: headerValues.carnetNo, startCol: 5, endCol: 5 },
                ]
            },
            {
                isMergedRow: true,
                cols: [
                    { text: '', startCol: 0, endCol: 2 },
                    { text: 'Contn.Sheet No:', startCol: 3, endCol: 4 },
                    { text: headerValues.contPageNo, startCol: 5, endCol: 5 },
                ]
            },
            { // This is the new blank row
                isMergedRow: true,
                cols: [
                    { text: '', startCol: 0, endCol: 5 }
                ]
            },
            ['Item No', 'Description', 'No of Pieces', 'Weight', 'Item Value', 'Country Of Origin']
        ];
    }


    // Helper function to draw a single horizontal line
    function drawHorizontalLine(doc, x, y, width, lineColor, lineWidth) {
        doc.strokeColor(lineColor)
            .lineWidth(lineWidth)
            .moveTo(x, y)
            .lineTo(x + width, y)
            .stroke();
    }

    // Helper function to draw vertical lines between columns for a specific height range
    function drawVerticalLines(doc, table, startY, endY) {
        doc.strokeColor(table.lineColor)
            .lineWidth(table.lineWidth);

        let verticalX = table.x;
        for (let i = 0; i < table.widths.length; i++) {
            doc.moveTo(verticalX, startY)
                .lineTo(verticalX, endY)
                .stroke();
            verticalX += table.widths[i];
        }
        // Draw the final right vertical line
        doc.moveTo(verticalX, startY)
            .lineTo(verticalX, endY)
            .stroke();
    }

    // Helper function to draw the table header
    function drawHeader(doc, table, headerData, cursorY, initialX, totalTableWidth) {
        const totalVerticalPadding = table.cellTopPadding + table.cellBottomPadding;
        const totalHorizontalPadding = table.cellHorizontalPadding * 2;

        let headerHeight = 0;
        let maxTextHeight = 0;
        doc.fontSize(table.headerFontSize).font('Helvetica');

        for (let i = 0; i < headerData.length; i++) {
            const textOptions = {
                width: table.widths[i] - totalHorizontalPadding,
                lineGap: 3
            };
            const h = doc.heightOfString(headerData[i], textOptions);
            if (h > maxTextHeight) maxTextHeight = h;
        }

        headerHeight = maxTextHeight + totalVerticalPadding;
        const headerLines = Math.ceil(maxTextHeight / doc.heightOfString('a', { lineGap: 3 }));

        let currentX = initialX;
        for (let i = 0; i < headerData.length; i++) {
            doc.rect(currentX, cursorY, table.widths[i], headerHeight).fill(table.headerColor);
            currentX += table.widths[i];
        }

        currentX = initialX;
        for (let i = 0; i < headerData.length; i++) {
            doc.fillColor(table.headerFontColor);
            doc.text(headerData[i], currentX + table.cellHorizontalPadding, cursorY + table.cellTopPadding, {
                width: table.widths[i] - totalHorizontalPadding,
                lineGap: 3
            });
            currentX += table.widths[i];
        }

        return { height: headerHeight, lines: headerLines };
    }

    // Helper function to draw a merged row
    function drawMergedRow(doc, table, rowData, cursorY, initialX) {
        const totalHorizontalPadding = table.cellHorizontalPadding * 2;

        const rowHeight = fixedHeaderRowHeight; // Use fixed height
        const fontSize = fixedHeaderFontSize;

        let currentX = initialX;

        doc.fontSize(fontSize).font('Helvetica'); // Ensure consistent font

        for (let i = 0; i < table.widths.length; i++) {
            const cell = rowData.cols.find(c => c.startCol === i);
            if (cell) {
                let mergedWidth = 0;
                for (let j = cell.startCol; j <= cell.endCol; j++) {
                    mergedWidth += table.widths[j];
                }
                const fillColor = table.rowColor;
                doc.rect(currentX, cursorY, mergedWidth, rowHeight).fill(fillColor);

                if (cell.text) {
                    doc.fillColor(table.bodyFontColor);
                    doc.text(cell.text, currentX + table.cellHorizontalPadding, cursorY + table.cellTopPadding, {
                        width: mergedWidth - totalHorizontalPadding,
                        height: rowHeight - table.cellTopPadding - table.cellBottomPadding,
                        lineGap: 3
                    });
                }
                currentX += mergedWidth;
                i = cell.endCol;
            } else {
                currentX += table.widths[i];
            }
        }

        return { height: rowHeight, lines: 1 };
    }

    // Helper function to draw the fixed header block
    function drawFixedHeader(doc, table, fixedHeaderData, cursorY, initialX, totalTableWidth) {
        let headerBlockHeight = 0;
        let headerBlockLines = 0;
        let horizontalLineYCoords: number[] = [];

        horizontalLineYCoords.push(cursorY); // Top of the entire header block

        // Draw merged rows (first 4 rows, including the new blank one)
        for (let i = 0; i < 4; i++) {
            const rowData = fixedHeaderData[i];
            const { height: rowHeight, lines: rowLines } = drawMergedRow(doc, table, rowData, cursorY, initialX);
            cursorY += rowHeight;
            headerBlockHeight += rowHeight;
            headerBlockLines += rowLines;
            horizontalLineYCoords.push(cursorY);
        }

        // Draw the main header
        const headerRow = fixedHeaderData[4];
        const { height: headerHeight, lines: headerLines } = drawHeader(doc, table, headerRow, cursorY, initialX, totalTableWidth);
        cursorY += headerHeight;
        headerBlockHeight += headerHeight;
        headerBlockLines += headerLines;
        horizontalLineYCoords.push(cursorY);

        // Now draw the horizontal lines for the entire header block
        for (const yCoord of horizontalLineYCoords) {
            drawHorizontalLine(doc, initialX, yCoord, totalTableWidth, table.lineColor, table.lineWidth);
        }

        // Now, manually draw the vertical lines for each header row based on its merged cells
        // Outer left border for the entire header block
        doc.moveTo(initialX, horizontalLineYCoords[0]).lineTo(initialX, cursorY).stroke();
        // Outer right border for the entire header block
        doc.moveTo(initialX + totalTableWidth, horizontalLineYCoords[0]).lineTo(initialX + totalTableWidth, cursorY).stroke();

        // Loop through the fixed header rows to draw internal vertical lines
        for (let i = 0; i < fixedHeaderData.length; i++) {
            const rowData = fixedHeaderData[i];
            const topY = horizontalLineYCoords[i];
            const bottomY = horizontalLineYCoords[i + 1];
            let currentX = initialX;

            if (Array.isArray(rowData)) {
                // Draw all vertical lines for the non-merged header row
                for (let j = 0; j < table.widths.length - 1; j++) {
                    currentX += table.widths[j];
                    doc.moveTo(currentX, topY).lineTo(currentX, bottomY).stroke();
                }
            } else if (i === 3) {
                // Special case for the blank merged row (4th row, index 3)
                // We want to draw all the vertical lines as if it's a regular row
                for (let j = 0; j < table.widths.length - 1; j++) {
                    currentX += table.widths[j];
                    doc.moveTo(currentX, topY).lineTo(currentX, bottomY).stroke();
                }
            }
            else {
                // Draw internal lines for other merged rows
                for (const cell of rowData.cols) {
                    let mergedWidth = 0;
                    for (let j = cell.startCol; j <= cell.endCol; j++) {
                        mergedWidth += table.widths[j];
                    }
                    currentX += mergedWidth;
                    // Don't draw a vertical line if it's the very last column's right border
                    if (cell.endCol < table.widths.length - 1) {
                        doc.moveTo(currentX, topY).lineTo(currentX, bottomY).stroke();
                    }
                }
            }
        }

        return { height: headerBlockHeight, endY: cursorY, lines: headerBlockLines };
    }

    // Helper function to draw the total row without borders or vertical lines
    function drawTotalRow(doc, table, totalValue, cursorY, initialX) {
        // const totalRowDataArray = ['', '', '', 'Total', totalValue.toFixed(2), ''];
        const totalRowDataArray = ['', '', '', 'Total', formatNumber(totalValue), ''];
        const totalVerticalPadding = table.cellTopPadding + table.cellBottomPadding;
        const totalHorizontalPadding = table.cellHorizontalPadding * 2;
        const totalTableWidth = table.widths.reduce((a, b) => a + b, 0);

        let totalRowHeight = 0;
        let maxTotalHeightInRow = 0;
        for (let j = 0; j < totalRowDataArray.length; j++) {
            const textOptions = {
                width: table.widths[j] - totalHorizontalPadding,
                lineGap: 3
            };
            const h = doc.heightOfString(totalRowDataArray[j], textOptions);
            if (h > maxTotalHeightInRow) {
                maxTotalHeightInRow = h;
            }
        }
        totalRowHeight = maxTotalHeightInRow + totalVerticalPadding;
        const linesInTotalRow = Math.ceil(maxTotalHeightInRow / doc.heightOfString('a', { lineGap: 3 }));

        const startY = cursorY + table.totalRowPaddingTop;

        // Draw the text only, without any rectangles or lines
        let currentX = initialX;
        doc.fontSize(table.fontSize);
        for (let j = 0; j < totalRowDataArray.length; j++) {
            doc.fillColor(table.bodyFontColor);
            doc.text(totalRowDataArray[j], currentX + table.cellHorizontalPadding, startY + table.cellTopPadding, {
                width: table.widths[j] - totalHorizontalPadding,
                lineGap: 3
            });
            currentX += table.widths[j];
        }

        return { height: totalRowHeight + table.totalRowPaddingTop, lines: linesInTotalRow, endY: startY + totalRowHeight };
    }


    // --- Function to manually draw a single data row ---
    function drawDataRow(doc, table, rowData, cursorY, initialX, isEvenRow) {
        const totalVerticalPadding = table.cellTopPadding + table.cellBottomPadding;
        const totalHorizontalPadding = table.cellHorizontalPadding * 2;
        const totalTableWidth = table.widths.reduce((a, b) => a + b, 0);

        let rowHeight = 0;
        let maxHeightInRow = 0;

        const rowDataArray = [
            rowData.itemNo,
            rowData.description,
            rowData.noOfPieces,
            rowData.weight,
            formatNumber(rowData.itemValue),  // formatted Item Value
            rowData.countryOfOrigin
        ];

        for (let j = 0; j < rowDataArray.length; j++) {
            const textOptions = { width: table.widths[j] - totalHorizontalPadding, lineGap: 3 };
            const h = doc.heightOfString(rowDataArray[j] || '', textOptions);
            if (h > maxHeightInRow) {
                maxHeightInRow = h;
            }
        }

        rowHeight = maxHeightInRow + totalVerticalPadding;
        const linesInRow = Math.ceil(maxHeightInRow / doc.heightOfString('a', { lineGap: 3 }));

        // Draw the data row
        const fillColor = isEvenRow ? table.alternatingRowColor : table.rowColor;
        doc.rect(initialX, cursorY, totalTableWidth, rowHeight).fill(fillColor); // Fill the entire row rectangle
        let currentX = initialX;
        doc.fontSize(table.fontSize);
        // for (let j = 0; j < rowDataArray.length; j++) {
        //     doc.fillColor(table.bodyFontColor);
        //     doc.text(rowDataArray[j], currentX + table.cellHorizontalPadding, cursorY + table.cellTopPadding, {
        //         width: table.widths[j] - totalHorizontalPadding,
        //         lineGap: 3
        //     });
        //     currentX += table.widths[j];
        // }

        for (let j = 0; j < rowDataArray.length; j++) {
            doc.fillColor(table.bodyFontColor);

            const alignRight = (j === 2 || j === 4); // right-align No of Pieces and Item Value

            doc.text(rowDataArray[j], currentX + table.cellHorizontalPadding, cursorY + table.cellTopPadding, {
                width: table.widths[j] - totalHorizontalPadding,
                lineGap: 3,
                align: alignRight ? 'right' : 'left'
            });

            currentX += table.widths[j];
        }

        return { height: rowHeight, lines: linesInRow, endY: cursorY + rowHeight };
    }

    // --- Function to manually draw the table from JSON data ---
    function drawTable(doc, table, jsonData, headerData) {
        let cursorY = table.y;
        const initialX = table.x;
        let continuationPageNo = 0;

        const totalTableWidth = table.widths.reduce((a, b) => a + b, 0);

        let rowStart = 0;

        while (rowStart < jsonData.length) {
            let linesUsed = 0;
            let rowsOnPage: any = [];
            let currentY = cursorY;
            let currentPageTotal = 0;

            // Draw fixed header block and count its visual lines
            const fixedHeaderData = getFixedHeaderData({ ...headerData, contPageNo: String(continuationPageNo) });
            const fixedHeaderInfo = drawFixedHeader(doc, table, fixedHeaderData, currentY, initialX, totalTableWidth);
            currentY = fixedHeaderInfo.endY;
            linesUsed += fixedHeaderInfo.lines;

            // Collect data rows that can fit in remaining lines
            for (let i = rowStart; i < jsonData.length; i++) {
                const rowData = jsonData[i];
                const isEvenRow = i % 2 === 0;

                const { height, lines } = drawDataRow(doc, table, rowData, -1000, initialX, isEvenRow); // simulate row height
                const remainingRows = jsonData.length - i - 1;
                const willBeLastPage = remainingRows === 0;
                const extraLines = 1 + (willBeLastPage ? 1 : 0);
                if (linesUsed + lines + extraLines + 1 > maxLinesPerPage) break; // +1 for total row
                rowsOnPage.push({ data: rowData, isEven: isEvenRow, height, lines });
                linesUsed += lines;
                rowStart++;
                currentPageTotal += parseFloat(rowData.itemValue);
            }

            // Render data rows
            let horizontalLineYCoords: number[] = [currentY];
            for (const row of rowsOnPage as any) {
                drawDataRow(doc, table, row.data, currentY, initialX, row.isEven);
                currentY += row.height;
                horizontalLineYCoords.push(currentY);
            }

            // Draw horizontal lines for data rows
            for (const yCoord of horizontalLineYCoords) {
                drawHorizontalLine(doc, initialX, yCoord, totalTableWidth, table.lineColor, table.lineWidth);
            }

            // Draw vertical lines for data block
            drawVerticalLines(doc, table, horizontalLineYCoords[0], currentY);

            // Draw total row
            const totalRowInfo = drawTotalRow(doc, table, currentPageTotal, currentY, initialX);
            currentY = totalRowInfo.endY;

            const isLastDataPage = rowStart >= jsonData.length;
            if (isLastDataPage) {
                const endMessage = '***** End of list, No item can be added *****';
                const fontSize = 10;
                const verticalGap = 10;

                doc.fontSize(fontSize).font('Helvetica-Bold');

                const textWidth = doc.widthOfString(endMessage);
                const centerX = (doc.page.width - textWidth) / 2;
                const endY = currentY + verticalGap;

                doc.text(endMessage, centerX, endY);
                currentY = endY + doc.heightOfString(endMessage); // update Y if needed
            }


            // Add new page if more data remains
            if (rowStart < jsonData.length) {
                doc.addPage();
                continuationPageNo++;
                cursorY = doc.page.margins.top;
            }
        }

        return continuationPageNo + 1;
    }

    // Draw the custom table and get the total page count
    const totalPages = drawTable(doc, table, jsonData, headerData);

    // Check if the total number of pages is even and add a "VOID" page if it is
    if (totalPages % 2 === 0) {
        doc.addPage();
        const voidText = 'VOID';
        doc.fontSize(14).font('Helvetica');
        const textWidth = doc.widthOfString(voidText);
        const centerX = (doc.page.width - textWidth) / 2;
        doc.text(voidText, centerX, doc.page.margins.top);
    }

    // Finalize the PDF file
    doc.end();

    const generalistFilePath = path.join(__dirname, '../../../public/carnet-pdf', 'p2.pdf')
    doc.pipe(fs.createWriteStream(generalistFilePath));

    console.log('PDF created successfully!');

    return "p2 done";
}

export const generateGeneralistPDF2 = async (carnetNumber: string) => {
    const pageWidth = doc.page.width;
    const seeAttachedText = 'See Attached';
    const seeAttachedWidth = doc.widthOfString(seeAttachedText);
    const uniqueNoText = `Carnet No: ${carnetNumber}`;
    const uniqueNoWidth = doc.widthOfString(uniqueNoText);

    // Center position for "See Attached"
    const centerX = pageWidth / 2;
    const seeAttachedX = centerX - (seeAttachedWidth / 2);

    // Position "Unique No" next to "See Attached"
    const spacing = 90; // gap between texts
    const uniqueNoX = seeAttachedX + seeAttachedWidth + spacing;

    // Vertically align both (e.g., 100 from top)
    const y = 100;

    // If unique number will overflow, adjust its X position to stay in same line
    let adjustedUniqueNoX = uniqueNoX;
    if (uniqueNoX + uniqueNoWidth > pageWidth - 50) {
        adjustedUniqueNoX = pageWidth - uniqueNoWidth - 50;
    }

    doc.text(seeAttachedText, seeAttachedX, y);
    doc.text(uniqueNoText, adjustedUniqueNoX, y);

    // Finalize PDF
    doc.end();

    const generalistFilePath = path.join(__dirname, '../../../public/carnet-pdf', 'p2.pdf')
    doc.pipe(fs.createWriteStream(generalistFilePath));

    return "p2 done"
}

export const generateGreenCoverPDF = async () => {
    const templatePath = path.join(__dirname, '../../..', 'public/pdf-templates', '2GeneralList.pdf');
    const existingPdfBytes = fs.readFileSync(templatePath);

    const pdfDoc = await pdfl.load(existingPdfBytes);
    const form = pdfDoc.getForm();

    let fields = form.getFields();
}

export const generateFinalPDF = async (inputFiles: string[], outputFile: string) => {
    const merger = new PDFMerger();

    for (const fileName of inputFiles) {
        const filePath = path.join(__dirname, '../../../public/carnet-pdf', fileName);
        console.log(`📄 Adding: ${filePath}`);

        try {
            await merger.add(filePath);
        } catch (err) {
            console.error(`❌ Failed to add PDF: ${fileName}`, err);
        }
    }

    const outputPath = path.join(__dirname, '../../../public/carnet-pdf', outputFile);

    try {
        await merger.save(outputPath);
        console.log(`✅ Merged PDF saved to ${outputPath}`);
    } catch (err) {
        console.error(`❌ Failed to save merged PDF`, err);
        throw new Error("Failed to save merged PDF");
    }
};

export const deleteFilesAsync = async (relativeFilePaths: string[]): Promise<void> => {
    for (const relativeFilePath of relativeFilePaths) {
        const filePath = path.join(__dirname, '../../../public/carnet-pdf', relativeFilePath);

        if (fs.existsSync(filePath)) {
            try {
                await fsPromises.unlink(filePath);
                console.log(`🗑️ Deleted: ${filePath}`);
            } catch (err) {
                console.error(`❌ Error deleting file: ${filePath}`, err);
            }
        } else {
            console.warn(`⚠️ File not found: ${filePath}`);
        }
    }
};