package com.restapi.controllers

import com.google.gson.Gson
import com.restapi.domain.*
import com.restapi.domain.Document
import com.restapi.domain.PurchaseOrder
import com.restapi.domain.Quotation
import com.restapi.domain.Session.currentUser
import org.apache.poi.hssf.usermodel.HSSFSheet
import org.apache.poi.hssf.usermodel.HSSFWorkbook
import com.restapi.domain.Session.database
import com.restapi.domain.Vendor
import org.apache.poi.hssf.usermodel.DVConstraint
import org.apache.poi.hssf.usermodel.HSSFDataValidation
import org.apache.poi.ss.usermodel.Cell
import org.apache.poi.ss.usermodel.CellType
import org.apache.poi.ss.usermodel.DateUtil
import org.apache.poi.ss.usermodel.Workbook
import org.apache.poi.ss.usermodel.WorkbookFactory
import org.apache.poi.ss.util.CellRangeAddressList
import java.io.File
import java.io.FileInputStream
import java.io.FileOutputStream
import java.text.SimpleDateFormat
import java.time.LocalDate
import java.time.ZoneId
import java.util.*

fun createHeaderRow(cols: List<String>, sh: HSSFSheet, wb: Workbook) {
    val boldFont = wb.createFont()
    boldFont.bold = true
    val style = wb.createCellStyle()
    style.setFont(boldFont)
    style.locked = true

    sh.createRow(0).apply {
        cols.forEachIndexed { index, value ->
            val cell = createCell(index)
            cell.setCellValue(value)
            cell.setCellStyle(style)
        }
    }
}

fun String.parseDate(format: String): Date? {
    val locale = Locale.getDefault()
    return try {
        SimpleDateFormat(format, locale).parse(this)
    } catch (e: Exception) {
        null
    }
}

fun dateFromCellHelper(cell: Cell): LocalDate? {
    val date = when (cell.cellType) {
        CellType.STRING -> cell.stringCellValue.parseDate("yyyy-MM-dd")
        CellType.NUMERIC -> {
            if (DateUtil.isCellDateFormatted(cell)) {
                cell.getDateCellValue()
            } else {
                null
            }
        }

        else -> null
    }
    return date?.toInstant()?.atZone(ZoneId.systemDefault())?.toLocalDate()
}

fun stringFromCellHelper(cell: Cell): String {
    val string = when (cell.cellType) {
        CellType.NUMERIC -> cell.numericCellValue.toString()
        CellType.STRING -> cell.stringCellValue
        else -> ""
    }
    return string
}

fun doubleFromCellHelper(cell: Cell): Double {
    val double = when (cell.cellType) {
        CellType.NUMERIC -> cell.numericCellValue
        CellType.STRING -> cell.stringCellValue.toDoubleOrNull()
        else -> 0.0
    }
    return double ?: 0.0
}

fun longIntFromCellHelper(cell: Cell): Long {
    val long = when (cell.cellType) {
        CellType.NUMERIC -> cell.numericCellValue.toLong()
        CellType.STRING -> cell.stringCellValue.toLong()
        else -> 0
    }
    return long
}

enum class FileType {
    QUOTES, POS, VENDORS, PRODS, DOCS
}

enum class EnumFor {
    UOM, DocType
}
fun saveExcelFileLocally(fileName: String, wb: Workbook) {
    val path = "./excel/"
    val out = FileOutputStream(path + fileName)
    wb.use {
        it.write(out)
    }
    out.close()
}

fun TemplateExcelFile(fileType: FileType) {
    when (fileType) {
        FileType.QUOTES -> {
            val headers: List<String> = listOf(
                "Quotation Number",
                "Date",
                "Open Till",
                "Product Id",
                "Product Name",
                "Product Unit Price",
                "Quantity",
                "Vendor Name",
                "Vendor Address",
                "RFQ Number",
                "Total Amount",
                "Terms and Conditions"
            )
            val wb = HSSFWorkbook()
            val sh = wb.createSheet()
            createHeaderRow(headers, sh, wb)
            saveExcelFileLocally("Quotes_Template.xls", wb)
        }

        FileType.POS -> {
            val headers: List<String> = listOf(
                "Number",
                "Date",
                "Open Till",
                "Reference Quotation Number",
                "Vendor Name",
                "Vendor Address",
                "Product Id",
                "Product Name",
                "Unit Price",
                "Quantity",
                "Total Amount",
                "Terms and Conditions"
            )
            val wb = HSSFWorkbook()
            val sh = wb.createSheet()
            createHeaderRow(headers, sh, wb)
            saveExcelFileLocally("Purchase_Order_Template.xls", wb)
        }

        FileType.VENDORS -> {
            val headers: List<String> = listOf(
                "Name",
                "MSME",
                "GST Number",
                "Address",
                "Rating",
                "Contact Name",
                "Contact Email",
                "Contact Mobile"
            )
            val wb = HSSFWorkbook()
            val sh = wb.createSheet()
            createHeaderRow(headers, sh, wb)
            saveExcelFileLocally("Vendors_Template.xls", wb)
        }

        FileType.PRODS -> {
            val headers: List<String> = listOf("Id", "Name", "Description", "HSN Code", "UOM")
            val wb = HSSFWorkbook()
            val sh = wb.createSheet()
            createHeaderRow(headers, sh, wb)
            val r0 = CellRangeAddressList(0, 1000, 4, 4)
            val dv0 = HSSFDataValidation(
                r0,
                DVConstraint.createExplicitListConstraint(arrayOf("LTR", "MTR", "NOS", "ALL"))
            ).apply {
                suppressDropDownArrow = true
            }
            sh.addValidationData(dv0)
            saveExcelFileLocally("Products_Template.xls", wb)
        }

        FileType.DOCS -> {

        }
    }
}

fun exportQuotations(quotes: List<Quotation>) {
    val wb = HSSFWorkbook()
    val sh = wb.createSheet()

    val headers: List<String> = listOf(
        "Quotation Number",
        "Date",
        "Open Till",
        "Product Id",
        "Product Name",
        "Product Unit Price",
        "Quantity",
        "Vendor Name",
        "Vendor Address",
        "RFQ Number",
        "Total AMount",
        "Terms and Conditions"
    )
    createHeaderRow(headers, sh, wb)
    var rowCnt = 1
    for (quote in quotes) {
        val prodCnt = quote.products.size

        for (j in 0..<prodCnt) {
            val row = sh.createRow(rowCnt++)
            var i = 0;
            row.createCell(i++).setCellValue(quote.quoteNum)
            row.createCell(i++).setCellValue(quote.quoteDate)
            row.createCell(i++).setCellValue(quote.validTill)
            //6 would be repeated
            row.createCell(i++).setCellValue(quote.products[j].productId)
            row.createCell(i++).setCellValue(quote.products[j].productName)
            row.createCell(i++).setCellValue(quote.products[j].unitPrice)
            row.createCell(i++).setCellValue(quote.products[j].quantity)

            row.createCell(i++).setCellValue(quote.vendor?.name)
            row.createCell(i++).setCellValue(quote.vendor?.address)

            row.createCell(i++).setCellValue(quote.reqForQuoteNum)
            row.createCell(i++).setCellValue(quote.totalAmount)

            row.createCell(i++).setCellValue(quote.tnc?.joinToString(";"))
        }
    }
    saveExcelFileLocally("Quotes.xls", wb)
}

fun exportVendors(vendors: List<Vendor>) {
    val wb = HSSFWorkbook()
    val sh = wb.createSheet()

    val headers: List<String> =
        listOf("No.", "Name", "MSME", "GST Number", "Address", "Rating", "Contact Name", "Contact Email", "Contact Mobile")
    createHeaderRow(headers, sh, wb)

    val totalCols = headers.size
    var rowCnt = 1

    for (vendor in vendors) {
        val contactCnt = vendor.contacts.size
        for (j in 0..<contactCnt) {
            val row = sh.createRow(rowCnt++)
            var i = 0
            row.createCell(i++).setCellValue((rowCnt - 1).toString())
            row.createCell(i++).setCellValue(vendor.name)
            row.createCell(i++).setCellValue(vendor.msme)
            row.createCell(i++).setCellValue(vendor.gstNumber)
            row.createCell(i++).setCellValue(vendor.address)
            row.createCell(i++).setCellValue(vendor.rating)
            row.createCell(i++).setCellValue(vendor.contacts[j].name)
            row.createCell(i++).setCellValue(vendor.contacts[j].email)
            row.createCell(i++).setCellValue(vendor.contacts[j].mobile)
        }
    }
    saveExcelFileLocally("VendorList.xls", wb)
}

fun exportProds(prods: List<Product>) {
    val wb = HSSFWorkbook()
    val sh = wb.createSheet()

    val headers: List<String> = listOf("Id", "Name", "Description", "HSN Code", "UOM")
    createHeaderRow(headers, sh, wb)

    var rowCnt = 1

    for (prod in prods) {
        val row = sh.createRow(rowCnt++)
        var i = 0
        row.createCell(i++).setCellValue(prod.id.toString())
        row.createCell(i++).setCellValue(prod.name)
        row.createCell(i++).setCellValue(prod.description)
        row.createCell(i++).setCellValue(prod.hsnCode)
        row.createCell(i++).setCellValue(prod.uom?.name)
    }
    saveExcelFileLocally("Products.xls", wb)
}

fun exportPos(pos: List<PurchaseOrder>) {
    val wb = HSSFWorkbook()
    val sh = wb.createSheet()

    val headers: List<String> = listOf(
        "Number",
        "Date",
        "Open Till",
        "Reference Quotation Number",
        "Vendor Name",
        "Vendor Address",
        "Product Id",
        "Product Name",
        "Unit Price",
        "Quantity",
        "Total Amount",
        "Terms and Conditions"
    )
    createHeaderRow(headers, sh, wb)

    var rowCnt = 1
    for (po in pos) {
        val prodCnt = po.products.size

        for (j in 0..<prodCnt) {
            val row = sh.createRow(rowCnt++)
            var i = 0
            row.createCell(i++).setCellValue(po.poNum)
            row.createCell(i++).setCellValue(po.poDate)
            row.createCell(i++).setCellValue(po.validTill)
            row.createCell(i++).setCellValue(po.referenceQuotation)
            row.createCell(i++).setCellValue(po.vendor?.name)
            row.createCell(i++).setCellValue(po.vendor?.address)

            //6 would be repeated
            row.createCell(i++).setCellValue(po.products[j].productId)
            row.createCell(i++).setCellValue(po.products[j].productName)
            row.createCell(i++).setCellValue(po.products[j].unitPrice)
            row.createCell(i++).setCellValue(po.products[j].quantity)

            row.createCell(i++).setCellValue(po.totalAmount)
            row.createCell(i++).setCellValue(po.tnc?.joinToString(";"))
        }
    }
    saveExcelFileLocally("Pos.xls", wb)
}

fun main() {
    //ImportFromExcel(FileType.QUOTES, "C:\\Users\\arsalan\\Downloads\\Book.xlsx")
    TemplateExcelFile(FileType.PRODS)
}

fun ImportFromExcel(fileType: FileType, filePath: String) {
    val wb = WorkbookFactory.create(File(filePath))
    val sh = wb.getSheetAt(0)

    when (fileType) {
        FileType.QUOTES -> {
            //Quote Number, ProductName, Product Quantity, Total Amount, RFQ Number, Quote Date, Valid Till, TNC[], Documents[]
            val quotesMap: MutableMap<String, Quotation> = mutableMapOf()
            val quotesList: List<Quotation> = mutableListOf()
            sh.rowIterator().forEach { row ->
                if (row == null) {
                    //reached eof
                    return@forEach
                }
                val quoteNumber = stringFromCellHelper(row.getCell(0))
                val quoteDt = dateFromCellHelper(row.getCell(1))
                val rfqNum = stringFromCellHelper(row.getCell(2))
                val quoteValidTill = dateFromCellHelper(row.getCell(3))
                val vendorName = stringFromCellHelper(row.getCell(4))
                val vendorGstNum = stringFromCellHelper(row.getCell(5))
                val vendorAddress = stringFromCellHelper(row.getCell(6))
                val prodName = stringFromCellHelper(row.getCell(7))
                val prodQuantity = doubleFromCellHelper(row.getCell(8))
                val prodUnitPrice = doubleFromCellHelper(row.getCell(9))
                val totalQuoteAmount = doubleFromCellHelper(row.getCell(10))
                val prod = POProducts("", prodName, prodUnitPrice, prodQuantity)

                if (quotesMap.containsKey(quoteNumber)) {
                    //duplicated row
                    quotesMap.get(quoteNumber)?.products?.add(prod)
                } else {
                    val v = Vendor()
                    v.apply {
                        name = vendorName
                        address = vendorAddress
                        gstNumber = vendorGstNum
                    }
                    val quote = Quotation()
                    quote.apply {
                        quoteNum = quoteNumber
                        quoteDate = quoteDt
                        reqForQuoteNum = rfqNum
                        validTill = quoteValidTill
                        products = mutableListOf(prod)
                        vendor = v
                        totalAmount = totalQuoteAmount
                    }
                    quotesMap.put(quoteNumber, quote)
                }
            }
            //docs, tncs
            // println("$quotesMap")

//            quotesMap.forEach { (k, v) ->
//                println("$v")
//            }
        }

        FileType.POS -> {
            //poNum, poDate, validTill, refQuoteNum, prodName, prodQuantity, totalAmount, products, vendorName, vendorGst, vendorAddress, tnc[]. docs[]
            val PoMap: MutableMap<String, PurchaseOrder> = mutableMapOf()
            sh.rowIterator().forEach { row ->
                if (row == null) return@forEach
                val poNum = stringFromCellHelper(row.getCell(0))
                val poDate = dateFromCellHelper(row.getCell(1))
                val refQuoteNum = stringFromCellHelper(row.getCell(2))
                val poValidTill = dateFromCellHelper(row.getCell(3))
                val prodName = stringFromCellHelper(row.getCell(4))
                val prodQuantity = doubleFromCellHelper(row.getCell(5))
                val vendorName = stringFromCellHelper(row.getCell(6))
                val vendorGstNum = stringFromCellHelper(row.getCell(7))
                val vendorAddress = stringFromCellHelper(row.getCell(8))
                val totalPoAmount = doubleFromCellHelper(row.getCell(9))
                //tncs, docs

                val prod = POProducts("", prodName, 0.0, prodQuantity, "")
                if (PoMap.containsKey(poNum)) {
                    //repeated row
                    PoMap.get(poNum)?.products?.add(prod)
                } else {
                    val vendor = Vendor()
                    vendor.name = vendorName
                    vendor.address = vendorAddress
                    vendor.gstNumber = vendorGstNum
                    val po = PurchaseOrder()
                    po.poNum = poNum
                    po.poDate = poDate
                    po.referenceQuotation = refQuoteNum
                    po.validTill = poValidTill
                    PoMap.put(poNum, po)
                }
            }
        }

        FileType.VENDORS -> {
            sh.rowIterator().forEach { row ->
                //name, msme, gstNum, addresss, rating, contacts
                if (row == null) return@forEach
                val name = stringFromCellHelper(row.getCell(0))
                val msme = stringFromCellHelper(row.getCell(1))
                val gstNum = stringFromCellHelper(row.getCell(2))
                val address = stringFromCellHelper(row.getCell(3))
                val rating = doubleFromCellHelper(row.getCell(4))

                //vendor object
                val vendor = Vendor()
                vendor.name = name
                vendor.address = address
                vendor.msme = msme
                vendor.gstNumber = gstNum
                vendor.rating = rating
            }
        }

        FileType.PRODS -> {
            sh.rowIterator().forEach { row ->
                if (row == null) return@forEach
                //id, name, description, hsnCode, uom
                val prodId = longIntFromCellHelper(row.getCell(0))
                val prodName = stringFromCellHelper(row.getCell(1))
                val prodDesc = stringFromCellHelper(row.getCell(2))
                val prodHsnCode = stringFromCellHelper(row.getCell(3))
                val prodUom = stringFromCellHelper(row.getCell(4))

                //new prod object
                val prod = Product()
                prod.id = prodId
                prod.name = prodName
                prod.description = prodDesc
                prod.hsnCode = prodHsnCode
                prod.uom = when (prodUom) {
                    "nos" -> UOM.NOS
                    "ltr" -> UOM.LTR
                    "mtr" -> UOM.MTR
                    else -> UOM.ALL
                }
            }
        }

        FileType.DOCS -> {
            sh.rowIterator().forEach { row ->
                //Document Name, Document Type, RefID, url
                if (row == null) return@forEach
                val docName = stringFromCellHelper(row.getCell(0))
                val docType = stringFromCellHelper(row.getCell(1))
                val refId = stringFromCellHelper(row.getCell(2))
                val url = stringFromCellHelper(row.getCell(3))

                //new doc object
                val doc = Document()
                doc.name = docName
                doc.typeOfDoc = when (docType) {
                    "quote" -> DocType.QUOTE
                    "po" -> DocType.PO
                    "invoice" -> DocType.INVOICE
                    else -> DocType.ALL
                }
                doc.refIdOfDoc = refId.toLong()
                doc.url = url
            }
        }
    }
}