FPSMS-backend/src/main/java/com/ffii/fpsms/m18/service/M18PurchaseOrderService.kt

package com.ffii.fpsms.m18.service

import com.ffii.core.utils.JwtTokenUtil
import com.ffii.fpsms.api.service.ApiCallerService
import com.ffii.fpsms.m18.M18Config
import com.ffii.fpsms.m18.enums.M18DataLogStatus
import com.ffii.fpsms.m18.model.*
import com.ffii.fpsms.m18.utils.CommonUtils
import com.ffii.fpsms.m18.web.models.M18CommonRequest
import com.ffii.fpsms.modules.deliveryOrder.service.DeliveryOrderLineService
import com.ffii.fpsms.modules.deliveryOrder.service.DeliveryOrderService
import com.ffii.fpsms.modules.master.service.ItemUomService
import com.ffii.fpsms.modules.master.service.ItemsService
import com.ffii.fpsms.modules.master.service.ShopService
import com.ffii.fpsms.modules.purchaseOrder.enums.PurchaseOrderLineStatus
import com.ffii.fpsms.modules.purchaseOrder.enums.PurchaseOrderStatus
import com.ffii.fpsms.modules.purchaseOrder.enums.PurchaseOrderType
import com.ffii.fpsms.modules.common.SettingNames
import com.ffii.fpsms.modules.purchaseOrder.service.PurchaseOrderLineService
import com.ffii.fpsms.modules.purchaseOrder.service.PurchaseOrderService
import com.ffii.fpsms.modules.purchaseOrder.web.model.SavePurchaseOrderLineRequest
import com.ffii.fpsms.modules.purchaseOrder.web.model.SavePurchaseOrderRequest
import com.ffii.fpsms.modules.settings.service.SettingsService
import org.slf4j.Logger
import org.slf4j.LoggerFactory
import org.springframework.stereotype.Service
import java.time.LocalDateTime
import kotlin.reflect.full.memberProperties
import java.time.format.DateTimeFormatter
import com.ffii.fpsms.m18.model.SyncResult

@Service
open class M18PurchaseOrderService(
    val m18Config: M18Config,
    val apiCallerService: ApiCallerService,
    val m18DataLogService: M18DataLogService,
    val purchaseOrderService: PurchaseOrderService,
    val purchaseOrderLineService: PurchaseOrderLineService,
    val deliveryOrderService: DeliveryOrderService,
    val deliveryOrderLineService: DeliveryOrderLineService,
    val itemsService: ItemsService,
    val shopService: ShopService,
    val itemUomService: ItemUomService,
    val m18MasterDataService: M18MasterDataService,
    val settingsService: SettingsService,
) {
    companion object {
        fun isStockInLookupPoCode(code: String?): Boolean {
            val trimmed = code?.trim().orEmpty()
            return trimmed.length > 14 && (trimmed.startsWith("PP") || trimmed.startsWith("PF"))
        }
    }

    val commonUtils = CommonUtils()
    val logger: Logger = LoggerFactory.getLogger(JwtTokenUtil::class.java)

    val lastModifyDateStart = "2025-05-14 14:00:00"
    val lastModifyDateEnd = "2025-05-14 14:30:00"
//    val lastModifyDateConds =
//        "lastModifyDate=largerOrEqual=${lastModifyDateStart}=and=lastModifyDate=lessOrEqual=${lastModifyDateEnd}"
//    val lastModifyDate = LocalDateTime.now().minusMinutes(30)
//    val commonConds =
//        "(beId=equal=${m18Config.BEID_PF}=or=beId=equal=${m18Config.BEID_PP}=or=beId=equal=${m18Config.BEID_TOA})=and=lastModifyDate=largerOrEqual=${lastModifyDate}"

    // M18 API
    val M18_LOAD_PURCHASE_ORDER_API = "/root/api/read/po"
    val M18_LOAD_PURCHASE_ORDER_BY_CODE_API = "/root/api/read/po"
    val M18_FETCH_PURCHASE_ORDER_LIST_API = "/search/search"

    // Include material po, oem po
    open fun getPurchaseOrdersWithType(request: M18CommonRequest): M18PurchaseOrderListResponseWithType? {
        val purchaseOrders = M18PurchaseOrderListResponseWithType(mutableListOf())
        val formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")
        val lastDateConds = if (request.modifiedDateFrom != null && request.modifiedDateTo != null) {
            val dateFrom = LocalDateTime.parse(request.modifiedDateFrom, formatter).toString()
            val dateTo = LocalDateTime.parse(request.modifiedDateTo, formatter).toString()
            
            "lastModifyDate=largerOrEqual=$dateFrom=and=lastModifyDate=lessOrEqual=$dateTo"
        } else {
            ""
        }

        val dDateConds = if (request.dDateFrom != null && request.dDateTo != null) {
            val dateFrom = LocalDateTime.parse(request.dDateFrom, formatter).toLocalDate().toString()
            val dateTo = LocalDateTime.parse(request.dDateTo, formatter).toLocalDate().toString()
            
            "dDate=largerOrEqual=$dateFrom=and=dDate=lessOrEqual=$dateTo"
        } else {
            ""
        }

        val dDateEqualConds = if (request.dDateEqual != null) {
            val dDateEqual = LocalDateTime.parse(request.dDateEqual, formatter).toLocalDate().toString()
            
            "dDate=equal=$dDateEqual"
        } else {
            ""
        }

        // Material PO
        val materialPoBuyers =
            commonUtils.listToString(listOf(m18Config.BEID_PP, m18Config.BEID_PF), "beId=equal=", "=or=")
        val materialPoSupplierNot = commonUtils.listToString(
            shopService.findM18VendorIdsByCodeRegexp(m18Config.MATERIAL_PO_SUPPLIER_NOT),
            "venId=unequal=",
            "=or="
        )
        var materialPoConds = "(${materialPoBuyers})=and=(${materialPoSupplierNot}))"
        
        if (request.modifiedDateFrom != null && request.modifiedDateTo != null) {
            materialPoConds += "=and=(${lastDateConds})"
        }
        if (request.dDateFrom != null && request.dDateTo != null) {
            materialPoConds += "=and=(${dDateConds})"
        }
        if (request.dDateEqual != null) {
            materialPoConds += "=and=(${dDateEqualConds})"
        }

        println("materialPoConds: ${materialPoConds}")


        val materialPoParams = M18PurchaseOrderListRequest(
            params = null,
            conds = materialPoConds
        )

        try {
            purchaseOrders.valuesWithType += Pair(
                PurchaseOrderType.MATERIAL,
                apiCallerService.get<M18PurchaseOrderListResponse, M18PurchaseOrderListRequest>(
                    M18_FETCH_PURCHASE_ORDER_LIST_API,
                    materialPoParams
                ).block()
            )
        } catch (e: Exception) {
            logger.error("(Getting Material Po list) Error on Function - ${e.stackTrace}")
            logger.error(e.message)
        }

        purchaseOrders.query = materialPoConds

        // Shop PO
        /* val shopPoBuyers = commonUtils.listToString(listOf(m18Config.BEID_TOA), "beId=equal=", "=or=")
        val shopPoSupplier = commonUtils.listToString(
            shopService.findM18VendorIdsByCodeRegexp(m18Config.SHOP_PO_SUPPLIER),
            "venId=equal=",
            "=or="
        )
        val shopPoConds = "(${shopPoBuyers})=and=(${shopPoSupplier})=and=(${lastModifyDateConds})"
        println("shopPoConds: ${shopPoConds}")
        val shopPoParams = M18PurchaseOrderListRequest(
            params = null,
            conds = shopPoConds
        )

        try {
            purchaseOrders.valuesWithType += Pair(
                PurchaseOrderType.SHOP, apiCallerService.get<M18PurchaseOrderListResponse, M18PurchaseOrderListRequest>(
                    M18_FETCH_PURCHASE_ORDER_LIST_API,
                    shopPoParams
                ).block()
            )
        } catch (e: Exception) {
            logger.error("(Getting Shop Po list) Error on Function - ${e.stackTrace}")
            logger.error(e.message)
        } */

        // OEM PO
        /* val oemPoBuyers = commonUtils.listToString(listOf(m18Config.BEID_PF, m18Config.BEID_PP), "beId=equal=", "=or=")
        val oemPoSupplier = commonUtils.listToString(
            shopService.findM18VendorIdsByCodeRegexp(m18Config.OEM_PO_SUPPLIER),
            "venId=equal=",
            "=or="
        )
        val oemPoConds = "(${oemPoBuyers})=and=(${oemPoSupplier})=and=(${lastModifyDateConds})"
        println("oemPoConds: ${oemPoConds}")
        val oemPoParams = M18PurchaseOrderListRequest(
            params = null,
            conds = oemPoConds
        )

        try {
            purchaseOrders.valuesWithType += Pair(
                PurchaseOrderType.OEM, apiCallerService.get<M18PurchaseOrderListResponse, M18PurchaseOrderListRequest>(
                    M18_FETCH_PURCHASE_ORDER_LIST_API,
                    oemPoParams
                ).block()
            )
        } catch (e: Exception) {
            logger.error("(Getting OEM Po list) Error on Function - ${e.stackTrace}")
            logger.error(e.message)
        } */

        return purchaseOrders
    }

    open fun getPurchaseOrder(id: Long): M18PurchaseOrderResponse? {
        val purchaseOrderParams = M18PurchaseOrderRequest(
            id = id
        )

        var purchaseOrder: M18PurchaseOrderResponse? = null

        try {
            purchaseOrder = apiCallerService.get<M18PurchaseOrderResponse, M18PurchaseOrderRequest>(
                M18_LOAD_PURCHASE_ORDER_API,
                purchaseOrderParams
            ).block()
        } catch (e: Exception) {
            logger.error("(Getting Po Detail) Error on Function - ${e.stackTrace}")
            logger.error(e.message)
        }

        return purchaseOrder
    }

    open fun getPurchaseOrderByCode(code: String): M18PurchaseOrderResponse? {
        var purchaseOrder: M18PurchaseOrderResponse? = null
        try {
            purchaseOrder = apiCallerService.get<M18PurchaseOrderResponse>(
                M18_LOAD_PURCHASE_ORDER_BY_CODE_API,
                mapOf("code" to code)
            ).block()
        } catch (e: Exception) {
            logger.error("(Getting Po Detail By Code) Error on Function - ${e.stackTrace}")
            logger.error(e.message)
        }
        return purchaseOrder
    }

    private fun resolvePoTypeByBeId(beId: Long?): PurchaseOrderType {
        return if (beId?.toString() == m18Config.BEID_TOA) PurchaseOrderType.SHOP else PurchaseOrderType.MATERIAL
    }

    open fun savePurchaseOrderByCode(code: String): SyncResult {
        // Follow the scheduler's original approach:
        // 1) use /search/search to find the PO id by code
        // 2) then sync by PO id (this reuses the same create/update logic)
        val conds = "(code=equal=$code)"
        return saveFromPoListSearch(conds, searchPurchaseOrdersByConds(conds))
    }

    /**
     * Stock-in `/po` lookup.
     * - Missing local PO: always sync from M18 (same as [savePurchaseOrderByCode]).
     * - Local pending + setting [SettingNames.M18_PO_STOCK_IN_REFRESH_IF_NEWER_ENABLED] true:
     *   sync from M18 (overwrite pending). Receiving / completed are not refreshed.
     * - Local PO + setting not true: do not call M18.
     */
    open fun savePurchaseOrderByCodeIfNewer(code: String): SyncResult =
        refreshForStockInLookup(code).syncResult

    open fun refreshForStockInLookup(code: String): StockInPoRefreshOutcome {
        val trimmed = code.trim()
        val enabled = isStockInRefreshIfNewerEnabled()
        val localStatus = purchaseOrderService.findActiveStatusByCode(trimmed)
        logger.info(
            "Purchase Order: stock-in ifNewer code={} settingEnabled={} localStatus={}",
            trimmed,
            enabled,
            localStatus ?: "<none>",
        )
        if (localStatus != null && !enabled) {
            logger.info(
                "Purchase Order: Skipping M18 sync — setting ${SettingNames.M18_PO_STOCK_IN_REFRESH_IF_NEWER_ENABLED} " +
                    "is not true. code=$trimmed status=$localStatus"
            )
            return StockInPoRefreshOutcome(
                action = StockInPoRefreshAction.SKIPPED_DISABLED,
                syncResult = SyncResult(
                    totalProcessed = 0,
                    totalSuccess = 0,
                    totalFail = 0,
                    query = "skipped (ifNewer): setting ${SettingNames.M18_PO_STOCK_IN_REFRESH_IF_NEWER_ENABLED} is not true"
                ),
            )
        }
        if (localStatus != null &&
            !PurchaseOrderStatus.PENDING.value.equals(localStatus, ignoreCase = true)
        ) {
            logger.info(
                "Purchase Order: Skipping M18 sync — local PO code=$trimmed status=$localStatus (only pending may be refreshed)."
            )
            return StockInPoRefreshOutcome(
                action = StockInPoRefreshAction.SKIPPED_NOT_PENDING,
                syncResult = SyncResult(
                    totalProcessed = 0,
                    totalSuccess = 0,
                    totalFail = 0,
                    query = "skipped (ifNewer): local PO not pending: $trimmed status=$localStatus"
                ),
            )
        }
        return StockInPoRefreshOutcome(
            action = StockInPoRefreshAction.SYNCED,
            syncResult = savePurchaseOrderByCode(trimmed),
        )
    }

    private fun isStockInRefreshIfNewerEnabled(): Boolean =
        settingsService.isBooleanTrueFromDb(SettingNames.M18_PO_STOCK_IN_REFRESH_IF_NEWER_ENABLED)

    private fun saveFromPoListSearch(
        query: String,
        poListResponse: M18PurchaseOrderListResponse?,
    ): SyncResult {
        val poValues = poListResponse?.values
        if (poValues.isNullOrEmpty()) {
            return SyncResult(
                totalProcessed = 1,
                totalSuccess = 0,
                totalFail = 1,
                query = query
            )
        }
        val request = M18PurchaseOrderListResponseWithType(
            valuesWithType = mutableListOf(Pair(PurchaseOrderType.MATERIAL, poListResponse)),
            query = query
        )
        return savePurchaseOrdersWithPreparedList(purchaseOrdersWithType = request)
    }

    private fun searchPurchaseOrdersByConds(conds: String): M18PurchaseOrderListResponse? {
        val searchRequest = M18PurchaseOrderListRequest(
            stSearch = "po",
            params = null,
            conds = conds
        )
        return try {
            apiCallerService.get<M18PurchaseOrderListResponse, M18PurchaseOrderListRequest>(
                M18_FETCH_PURCHASE_ORDER_LIST_API,
                searchRequest
            ).block()
        } catch (e: Exception) {
            logger.error("(Getting Po List By Code) Error on Function - ${e.stackTrace}")
            logger.error(e.message)
            null
        }
    }

    open fun savePurchaseOrders(request: M18CommonRequest) : SyncResult{
        val purchaseOrdersWithType = getPurchaseOrdersWithType(request)
        return savePurchaseOrdersWithPreparedList(
            purchaseOrdersWithType = purchaseOrdersWithType,
            preloadPurchaseOrderDetails = null
        )
    }

    private fun savePurchaseOrdersWithPreparedList(
        purchaseOrdersWithType: M18PurchaseOrderListResponseWithType?,
        preloadPurchaseOrderDetails: Map<Long, M18PurchaseOrderResponse?>? = null
    ): SyncResult {
        logger.info("--------------------------------------------Start - Saving M18 Purchase Order--------------------------------------------")

        val successList = mutableListOf<Long>()
        val successDetailList = mutableListOf<Long>()
        val failList = mutableListOf<Long>()
        val failDetailList = mutableListOf<Long>()
        val affectedItemIds = mutableSetOf<Long>()
        val uomByM18IdCache = mutableMapOf<Long, com.ffii.fpsms.modules.master.entity.ItemUom?>()

        val poRefType = "Purchase Order"
        val poLineRefType = "Purchase Order Line"

        if (purchaseOrdersWithType != null) {
            // Loop for Purchase Orders (values)
            purchaseOrdersWithType.valuesWithType.forEach { purchaseOrderWithType ->
                // if success
                val purchaseOrdersValues = purchaseOrderWithType.second?.values
                // if fail
                val purchaseOrdersMessages = purchaseOrderWithType.second?.messages

                if (purchaseOrdersValues != null) {
                    purchaseOrdersValues.forEach { purchaseOrder ->
                        val purchaseOrderDetail =
                            preloadPurchaseOrderDetails?.get(purchaseOrder.id) ?: getPurchaseOrder(purchaseOrder.id)

                        var purchaseOrderId: Long? = null //FP-MTMS

                        // Process for Purchase Order (mainpo)
                        // Assume only one PO in the PO (search by PO ID)
                        val mainpo = purchaseOrderDetail?.data?.mainpo?.get(0)
                        val pot = purchaseOrderDetail?.data?.pot
                        val purchaseOrderLineMessage = purchaseOrderDetail?.messages
                        logger.info("purchaseOrderDetail: data is null? ${purchaseOrderDetail?.data == null} | mainpo is null? ${purchaseOrderDetail?.data?.mainpo == null} | get(0) is null? ${purchaseOrderDetail?.data?.mainpo?.get(0) == null}")

                        // purchase_order + m18_data_log table
                        if (mainpo != null) {
                            val m18PurchaseOrderId = mainpo.id
                            // Find the latest m18 data log by m18 id & type
//                            logger.info("${poRefType}: Finding For Latest M18 Data Log...")
                            val latestPurchaseOrderLog =
                                m18DataLogService.findLatestM18DataLogWithSuccess(m18PurchaseOrderId, poRefType)

                            val existingPurchaseOrderForSync =
                                latestPurchaseOrderLog?.id?.let { purchaseOrderService.findByM18DataLogId(it) }
                            if (existingPurchaseOrderForSync != null &&
                                existingPurchaseOrderForSync.status != PurchaseOrderStatus.PENDING
                            ) {
                                logger.info(
                                    "${poRefType}: Skipping M18 sync — local PO id=${existingPurchaseOrderForSync.id} " +
                                        "code=${existingPurchaseOrderForSync.code} status=${existingPurchaseOrderForSync.status?.value} " +
                                        "(only pending may be overwritten). M18 ID: $m18PurchaseOrderId"
                                )
                                return@forEach
                            }

//                            logger.info(latestPurchaseOrderLog.toString())
                            // Save to m18_data_log table
//                            logger.info("${poRefType}: Saving for M18 Data Log...")
                            val mainpoJson =
                                mainpo::class.memberProperties.associate { prop -> prop.name to prop.getter.call(mainpo) }
                                    .toMutableMap()

                            val saveM18PurchaseOrderLogRequest = SaveM18DataLogRequest(
                                id = null,
                                refType = poRefType,
                                m18Id = m18PurchaseOrderId,
                                m18LastModifyDate = commonUtils.timestampToLocalDateTime(mainpo.lastModifyDate),
//                                dataLog = mainpoJson,
                                statusEnum = M18DataLogStatus.NOT_PROCESS
                            )

                            val saveM18PurchaseOrderLog =
                                m18DataLogService.saveM18DataLog(saveM18PurchaseOrderLogRequest)
//                    logger.info("${poRefType}: Saved M18 Data Log. ID: ${saveM18PurchaseOrderLog.id}")

                            try {
                                // Find the purchase_order if exist (re-use lookup from pending guard above)
//                                logger.info("${poRefType}: Finding exising purchase order...")
                                val existingPurchaseOrder = existingPurchaseOrderForSync
//                                logger.info("${poRefType}: Exising purchase order ID: ${existingPurchaseOrder?.id}")

                                // Save to purchase_order table
//                                logger.info("${poRefType}: Saving purchase order...")
                                val savePurchaseOrderRequest = SavePurchaseOrderRequest(
                                    id = existingPurchaseOrder?.id,
                                    code = mainpo.code,
                                    m18SupplierId = mainpo.venId,
                                    m18ShopId = mainpo.virDeptId,
                                    m18CurrencyId = mainpo.curId,
                                    orderDate = commonUtils.timestampToLocalDateTime(mainpo.tDate),
                                    estimatedArrivalDate = commonUtils.timestampToLocalDateTime(mainpo.dDate),
                                    completeDate = null,
                                    status = PurchaseOrderStatus.PENDING.value,
                                        type = resolvePoTypeByBeId(mainpo.beId).value,
                                    m18DataLogId = saveM18PurchaseOrderLog.id,
                                    m18BeId = mainpo.beId,
                                    m18CreatedUId = mainpo.createUid,
                                )

                                val savePurchaseOrderResponse =
                                    purchaseOrderService.savePurchaseOrder(savePurchaseOrderRequest)
                                purchaseOrderId = savePurchaseOrderResponse.id

                                // Update m18_data_log with success
                                val successSaveM18PurchaseOrderLogRequest = SaveM18DataLogRequest(
                                    id = saveM18PurchaseOrderLog.id,
                                    dataLog = mainpoJson,
                                    statusEnum = M18DataLogStatus.SUCCESS
                                )

                                m18DataLogService.saveM18DataLog(successSaveM18PurchaseOrderLogRequest)

                                // log success info
                                successList.add(m18PurchaseOrderId)
                                logger.info("${poRefType}: Saved purchase order. ID: ${savePurchaseOrderResponse.id} | M18 ${poRefType} ID: ${m18PurchaseOrderId}")

                            } catch (e: Exception) {
                                failList.add(m18PurchaseOrderId)
//                                logger.error("${poRefType}: Saving Failure!")
                                logger.error("Error on Function - ${e.stackTrace} | Type: ${poRefType} | M18 ID: ${m18PurchaseOrderId} | Different? ${mainpo.id}")
                                logger.error(e.message)

                                val errorSaveM18PurchaseOrderLogRequest = SaveM18DataLogRequest(
                                    id = saveM18PurchaseOrderLog.id,
                                    dataLog = mutableMapOf(Pair("Exception Message", e.message)),
                                    statusEnum = M18DataLogStatus.FAIL
                                )

                                m18DataLogService.saveM18DataLog(errorSaveM18PurchaseOrderLogRequest)
//                                logger.error("${poRefType}: M18 Data Log Updated! Please see the error. ID: ${saveM18PurchaseOrderLogRequest.id}")
                            }

                            // purchase_order_line + m18_data_log
                            if (pot != null) {
                                // Loop for Purchase Order Lines (pot)
                                pot.forEach { line ->

                                    // Find the latest m18 data log by m18 id & type
//                                    logger.info("${poLineRefType}: Finding For Latest M18 Data Log...")
                                    val latestPurchaseOrderLineLog =
                                        m18DataLogService.findLatestM18DataLogWithSuccess(line.id, poLineRefType)
                                    // logger.info("${poLineRefType}: Latest M18 Data Log ID: ${latestPurchaseOrderLineLog?.id}")

                                    // Save to m18_data_log table
//                                    logger.info("${poLineRefType}: Saving for M18 Data Log...")
                                    val lineJson =
                                        line::class.memberProperties.associate { prop ->
                                            prop.name to prop.getter.call(
                                                line
                                            )
                                        }
                                            .toMutableMap()
                                    val saveM18PurchaseOrderLineLogRequest = SaveM18DataLogRequest(
                                        id = null,
                                        refType = poLineRefType,
                                        m18Id = line.id,
                                        m18LastModifyDate = commonUtils.timestampToLocalDateTime(mainpo.lastModifyDate),
//                                        dataLog = lineJson,
                                        statusEnum = M18DataLogStatus.NOT_PROCESS
                                    )

                                    val saveM18PurchaseOrderLineLog =
                                        m18DataLogService.saveM18DataLog(saveM18PurchaseOrderLineLogRequest)

                                    // logger.info("${poLineRefType}: Saved M18 Data Log. ID: ${saveM18PurchaseOrderLineLog.id}")
//                                    logger.info("${poLineRefType}: Finding item...")
                                    val itemId: Long? = m18MasterDataService.resolveLocalItemId(line.proId)
                                    logger.info("${poLineRefType}: Item ID: ${itemId} | M18 Item ID: ${line.proId}")

                                    if (itemId == null) {
                                        failDetailList.add(line.id)
                                        logger.error(
                                            "${poLineRefType}: PO ${mainpo.code}: Cannot resolve local item for M18 proId=${line.proId}, skipping line ${line.id}"
                                        )
                                        val errorSaveM18PurchaseOrderLineLogRequest = SaveM18DataLogRequest(
                                            id = saveM18PurchaseOrderLineLog.id,
                                            dataLog = mutableMapOf(
                                                "Exception Message" to "PO ${mainpo.code} Cannot resolve local item for M18 proId=${line.proId}"
                                            ),
                                            statusEnum = M18DataLogStatus.FAIL
                                        )
                                        m18DataLogService.saveM18DataLog(errorSaveM18PurchaseOrderLineLogRequest)
                                        return@forEach
                                    }

                                    try {
                                        // Find the purchase_order_line if exist (stable key: PO + M18 line id)
//                                        logger.info("${poLineRefType}: Finding exising purchase order line...")
                                        val existingPurchaseOrderLine =
                                            purchaseOrderId?.let { pid ->
                                                purchaseOrderLineService.findPurchaseOrderLineByPurchaseOrderAndM18LineId(
                                                    pid,
                                                    line.id
                                                )
                                            } ?: latestPurchaseOrderLineLog?.id?.let {
                                                purchaseOrderLineService.findPurchaseOrderLineByM18Id(it)
                                            }
//                                        logger.info("${poLineRefType}: Exising purchase order line ID: ${existingPurchaseOrderLine?.id}")

                                        // Save to purchase_order_line table
//                                        logger.info("${poLineRefType}: Saving purchase order line...")
                                        val purchaseItemUom = itemId?.let { itemUomService.findPurchaseUnitByItemId(it) }
                                        val m18ItemUom = uomByM18IdCache.getOrPut(line.unitId) {
                                            itemUomService.findByM18Id(line.unitId)
                                        }
                                        val qtyM18 = line.qty
                                        val sourceUomId = m18ItemUom?.uom?.id
                                        // qtyM18 is the original qty in M18 line uom.
                                        // System PO line.qty must be qty in purchase unit.
                                        val convertedQty = if (itemId != null && sourceUomId != null) {
                                            itemUomService.convertQtyToPurchaseQty(itemId, sourceUomId, qtyM18)
                                        } else {
                                            qtyM18
                                        }
                                        val savePurchaseOrderLineRequest = SavePurchaseOrderLineRequest(
                                            id = existingPurchaseOrderLine?.id,
                                            itemId = itemId,
                                            uomId = purchaseItemUom?.uom?.id,
                                            purchaseOrderId = purchaseOrderId,
                                            qty = convertedQty,
                                            qtyM18 = qtyM18,
                                            up = line.up,
                                            price = line.amt,
//                                            m18CurrencyId = mainpo.curId,
                                            status = existingPurchaseOrderLine?.status?.value
                                                ?: PurchaseOrderLineStatus.PENDING.value,
                                            m18DataLogId = saveM18PurchaseOrderLineLog.id,
                                            m18Discount = line.disc,
                                            m18Lot = line.lot,
                                            uomIdM18 = sourceUomId
                                        )

                                        val savePurchaseOrderLineResponse =
                                            purchaseOrderLineService.savePurchaseOrderLine(savePurchaseOrderLineRequest)

                                        // Update m18_data_log with success
                                        val successSaveM18PurchaseOrderLineLogRequest = SaveM18DataLogRequest(
                                            id = saveM18PurchaseOrderLineLog.id,
                                            dataLog = lineJson,
                                            statusEnum = M18DataLogStatus.SUCCESS
                                        )

                                        m18DataLogService.saveM18DataLog(successSaveM18PurchaseOrderLineLogRequest)

                                        // log success info
                                        successDetailList.add(line.id)
//                                        logger.info("${poLineRefType}: Purchase order ID: ${purchaseOrderId} | M18 ID: ${purchaseOrder.id}")
                                        logger.info("${poLineRefType}: Saved purchase order line. ID: ${savePurchaseOrderLineResponse.id} | M18 Line ID: ${line.id} | Purchase order ID: ${purchaseOrderId} | M18 ID: ${purchaseOrder.id}")
                                        itemId?.let { affectedItemIds.add(it) }
                                    } catch (e: Exception) {
                                        failDetailList.add(line.id)
//                                        logger.error("${poLineRefType}: Saving Failure!")
                                        logger.error("Error on Function - ${e.stackTrace} | Type: ${poLineRefType} | M18 ID: ${line.id}")
                                        logger.error(e.message)

                                        val errorSaveM18PurchaseOrderLineLogRequest = SaveM18DataLogRequest(
                                            id = saveM18PurchaseOrderLineLog.id,
                                            dataLog = mutableMapOf(Pair("Exception Message", e.message)),
                                            statusEnum = M18DataLogStatus.FAIL
                                        )

                                        m18DataLogService.saveM18DataLog(errorSaveM18PurchaseOrderLineLogRequest)
//                                        logger.error("${poLineRefType}: M18 Data Log Updated! Please see the error. ID: ${saveM18PurchaseOrderLineLog.id}")
                                    }
                                }
                                // Mark as deleted any local PO lines that no longer exist in M18 (removed there)
                                if (purchaseOrderId != null) {
                                    val m18LineIds = pot.map { it.id }.toSet()
                                    val (markedDeleted, deletedItemIds) =
                                        purchaseOrderLineService.markDeletedLinesNotInM18(purchaseOrderId, m18LineIds)
                                    affectedItemIds.addAll(deletedItemIds)
                                    if (markedDeleted > 0) {
                                        logger.info("${poLineRefType}: Marked $markedDeleted line(s) as deleted (not in M18). PO ID: $purchaseOrderId | M18 PO ID: ${purchaseOrder.id}")
                                    }
                                    val (dupesRemoved, dupeItemIds) =
                                        purchaseOrderLineService.markDuplicatePurchaseOrderLinesForSameM18LineId(
                                            purchaseOrderId,
                                            m18LineIds
                                        )
                                    affectedItemIds.addAll(dupeItemIds)
                                    if (dupesRemoved > 0) {
                                        logger.info("${poLineRefType}: Marked $dupesRemoved duplicate line(s) as deleted (same M18 line id). PO ID: $purchaseOrderId | M18 PO ID: ${purchaseOrder.id}")
                                    }
                                }
                            } else {
                                // pot
//                                logger.error("${poLineRefType}: Saving Failure!")
                                val saveM18PurchaseOrderLineLogRequest = SaveM18DataLogRequest(
                                    id = null,
                                    refType = "${poLineRefType}",
                                        m18Id = m18PurchaseOrderId,
                                    m18LastModifyDate = commonUtils.timestampToLocalDateTime(mainpo.lastModifyDate),
//                                    dataLog = mutableMapOf(Pair("Error Message", "${poLineRefType} is null")),
                                    dataLog = mutableMapOf(
                                        Pair(
                                            "${poLineRefType} Error Message",
                                            "pot is null"
                                        ),
                                        Pair(
                                            "${poLineRefType} Error Code",
                                            purchaseOrderLineMessage?.get(0)?.msgCode ?: "No Msg Code from M18"
                                        ),
                                        Pair(
                                            "${poLineRefType} Error Detail",
                                            purchaseOrderLineMessage?.get(0)?.msgDetail ?: "No Msg Detail from M18"
                                        ),
                                    ),
                                    statusEnum = M18DataLogStatus.FAIL
                                )

                                val errorLog = m18DataLogService.saveM18DataLog(saveM18PurchaseOrderLineLogRequest)
                                logger.error("${poLineRefType}: M18 Data Log Updated! Please see the error. ID: ${errorLog.id}")
                            }
                        } else {
                            // mainpo
                            failList.add(purchaseOrder.id)
//                            logger.error("${poRefType}: Saving Failure!")
                            val saveM18DataLogRequest = SaveM18DataLogRequest(
                                id = null,
                                refType = "${poRefType}",
                                m18Id = purchaseOrder.id,
                                // m18LastModifyDate = if(mainpo?.lastModifyDate != null) commonUtils.instantToLocalDateTime(mainpo.lastModifyDate) else LocalDateTime.now(),
                                m18LastModifyDate = LocalDateTime.now(),
                                dataLog = mutableMapOf(
                                    Pair(
                                        "${poRefType} Error",
                                        "mainpo is null"
                                    ),
                                    Pair(
                                        "${poRefType} Error Code",
                                        purchaseOrdersMessages?.get(0)?.msgCode ?: "No Msg Code from M18"
                                    ),
                                    Pair(
                                        "${poRefType} Error Detail",
                                        purchaseOrdersMessages?.get(0)?.msgDetail ?: "No Msg Detail from M18"
                                    ),
                                ),
                                statusEnum = M18DataLogStatus.FAIL
                            )

                            val errorLog = m18DataLogService.saveM18DataLog(saveM18DataLogRequest)
                            logger.error("${poLineRefType}: M18 Data Log Updated! Please see the error. ID: ${errorLog.id}")
                        }
                    }
                } else {
                    logger.error("${poRefType} List is null. May occur errors.")
                }
            }
        } else {
            logger.error("${poRefType} List is null. May occur errors.")
        }

        // End of save. Check result
//        logger.info("Total Success (${poRefType}) (${successList.size}): $successList")
        logger.info("Total Success (${poRefType}) (${successList.size})")
//        if (failList.size > 0) {
        logger.error("Total Fail (${poRefType}) (${failList.size}): $failList")
//        }

//        logger.info("Total Success (${poLineRefType}) (${successDetailList.size}): $successDetailList")
        logger.info("Total Success (${poLineRefType}) (${successDetailList.size})")
//        if (failDetailList.size > 0) {
        logger.error("Total Fail (${poLineRefType}) (${failDetailList.size}): $failDetailList")
//        }

        val (feeMarked, feeItemIds) = purchaseOrderLineService.markDeletedLinesWithFeeItems()
        affectedItemIds.addAll(feeItemIds)
        if (feeMarked > 0) {
            logger.info("Marked $feeMarked PO line(s) as deleted (isFee items).")
        }

        if (affectedItemIds.isNotEmpty()) {
            itemsService.updateAverageUnitPriceForItems(affectedItemIds)
            logger.info("Average unit price updated for ${affectedItemIds.size} item(s) after PO sync.")
        }

        logger.info("--------------------------------------------End - Saving M18 Purchase Order--------------------------------------------")

        return SyncResult(
            totalProcessed = successList.size + failList.size,
            totalSuccess = successList.size,
            totalFail = failList.size,
            query = purchaseOrdersWithType?.query ?: ""
        )
    }
}

enum class StockInPoRefreshAction(val headerValue: String) {
    SKIPPED_DISABLED("skipped_disabled"),
    SKIPPED_NOT_PENDING("skipped_not_pending"),
    SYNCED("synced"),
}

data class StockInPoRefreshOutcome(
    val action: StockInPoRefreshAction,
    val syncResult: SyncResult,
)