/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

import org.apache.ofbiz.entity.condition.*
import org.apache.ofbiz.entity.util.*
import org.apache.ofbiz.service.ServiceUtil
import org.apache.ofbiz.base.util.*

shipmentId = request.getParameter("shipmentId")
orderId = request.getParameter("purchaseOrderId")
shipGroupSeqId = request.getParameter("shipGroupSeqId")
context.shipmentId = shipmentId
context.shipGroupSeqId = shipGroupSeqId

// Retrieve the map resident in session which stores order item quantities to receive
itemQuantitiesToReceive = session.getAttribute("purchaseOrderItemQuantitiesToReceive")
if (itemQuantitiesToReceive) {
    sessionShipmentId = itemQuantitiesToReceive._shipmentId
    sessionOrderId = itemQuantitiesToReceive._orderId
    if ((sessionShipmentId && !sessionShipmentId.equals(shipmentId)) ||
        ((sessionOrderId && !sessionOrderId.equals(orderId)))        ||
         "Y".equals(request.getParameter("clearAll"))) {

             // Clear the map if the shipmentId or orderId are different than the current ones, or
             // if the clearAll parameter is present
             itemQuantitiesToReceive.clear()
    }
}

shipment = from("Shipment").where("shipmentId", shipmentId).queryOne()
context.shipment = shipment
if (!shipment) {
    return
}

isPurchaseShipment = "PURCHASE_SHIPMENT".equals(shipment.shipmentTypeId)
context.isPurchaseShipment = isPurchaseShipment
if (!isPurchaseShipment) {
    return
}

facility = shipment.getRelatedOne("DestinationFacility", false)
context.facility = facility
context.facilityId = shipment.destinationFacilityId
context.now = UtilDateTime.nowTimestamp()

if (!orderId) {
    orderId = shipment.primaryOrderId
}
if (!shipGroupSeqId) {
    shipGroupSeqId = shipment.primaryShipGroupSeqId
}
context.orderId = orderId

if (!orderId) {
    return
}

orderHeader = from("OrderHeader").where("orderId", orderId).queryOne()
context.orderHeader = orderHeader
if (!orderHeader) {
    return
}

isPurchaseOrder = "PURCHASE_ORDER".equals(orderHeader.orderTypeId)
context.isPurchaseOrder = isPurchaseOrder
if (!isPurchaseOrder) {
    return
}

// Get the base currency from the facility owner, for currency conversions
baseCurrencyUomId = null
if (facility) {
    owner = facility.getRelatedOne("OwnerParty", false)
    if (owner) {
        result = runService('getPartyAccountingPreferences', [organizationPartyId : owner.partyId, userLogin : request.getAttribute("userLogin")])
        if (!ServiceUtil.isError(result) && result.partyAccountingPreference) {
            ownerAcctgPref = result.partyAccountingPreference
        }
    }
    if (ownerAcctgPref) {
        baseCurrencyUomId = ownerAcctgPref.baseCurrencyUomId
    }
}

inventoryItemTypes = from("InventoryItemType").queryList()
context.inventoryItemTypes = inventoryItemTypes

// Populate the tracking map with shipment and order IDs
if (!itemQuantitiesToReceive) {
    itemQuantitiesToReceive = [_shipmentId : shipmentId, _orderId : orderId]
}

oiasgaLimitMap = null
if (shipGroupSeqId) {
    oiasgaLimitMap = [shipGroupSeqId : shipGroupSeqId]
}

orderItemDatas = [:] as TreeMap
totalAvailableToReceive = 0

// Populate the order item data for the FTL
orderItems = orderHeader.getRelated("OrderItemAndShipGroupAssoc", oiasgaLimitMap, ['shipGroupSeqId', 'orderItemSeqId'], false)
orderItems.each { orderItemAndShipGroupAssoc ->
    product = orderItemAndShipGroupAssoc.getRelatedOne("Product", false)

    // Get the order item, since the orderItemAndShipGroupAssoc's quantity field is manipulated in some cases
    orderItem = from("OrderItem").where("orderId", orderId, "orderItemSeqId", orderItemAndShipGroupAssoc.orderItemSeqId).queryOne()
    orderItemData = [:]

    // Get the item's ordered quantity
    totalOrdered = 0
    ordered = orderItem.getDouble("quantity")
    if (ordered) {
        totalOrdered += ordered.doubleValue()
    }
    cancelled = orderItem.getDouble("cancelQuantity")
    if (cancelled) {
        totalOrdered -= cancelled.doubleValue()
    }

    // Get the item quantity received from all shipments via the ShipmentReceipt entity
    totalReceived = 0.0
    receipts = from("ShipmentReceipt").where("orderId", orderId, "orderItemSeqId", orderItem.orderItemSeqId).queryList()
    fulfilledReservations = [] as ArrayList
    if (receipts) {
        receipts.each { rec ->
            accepted = rec.getDouble("quantityAccepted")
            rejected = rec.getDouble("quantityRejected")
            if (accepted) {
                totalReceived += accepted.doubleValue()
            }
            if (rejected) {
                totalReceived += rejected.doubleValue()
            }
            // Get the reservations related to this receipt
            oisgirs = from("OrderItemShipGrpInvRes").where("inventoryItemId", rec.inventoryItemId).queryList()
            if (oisgirs) {
                fulfilledReservations.addAll(oisgirs)
            }
        }
    }
    orderItemData.fulfilledReservations = fulfilledReservations

    // Update the unit cost with the converted value, if any
    if (baseCurrencyUomId && orderHeader.currencyUom) {
        if (product) {
            result = runService('convertUom', [uomId : orderHeader.currencyUom, uomIdTo : baseCurrencyUomId, originalValue : orderItem.unitPrice])
            if (!ServiceUtil.isError(result)) {
                orderItem.unitPrice = result.convertedValue
            }
        }
    }

    // Retrieve the backordered quantity
    // TODO: limit to a facility? The shipment destination facility is not necessarily the same facility as the inventory
    conditions = [EntityCondition.makeCondition("productId", EntityOperator.EQUALS, product.productId),
                  EntityCondition.makeCondition("availableToPromiseTotal", EntityOperator.LESS_THAN, BigDecimal.ZERO)]
    negativeInventoryItems = from("InventoryItem").where(conditions).queryList()
    backOrderedQuantity = 0
    negativeInventoryItems.each { negativeInventoryItem ->
        backOrderedQuantity += negativeInventoryItem.getDouble("availableToPromiseTotal").doubleValue()
    }
    orderItemData.backOrderedQuantity = Math.abs(backOrderedQuantity)

    // Calculate how many units it should be possible to recieve for this purchase order
    availableToReceive = totalOrdered - totalReceived
    totalAvailableToReceive += availableToReceive
    orderItemData.availableToReceive = availableToReceive
    orderItemData.totalQuantityReceived = totalReceived
    orderItemData.shipGroupSeqId = orderItemAndShipGroupAssoc.shipGroupSeqId
    orderItemData.orderItem = orderItem
    orderItemData.product = product
    orderItemDatas.put(orderItem.orderItemSeqId, orderItemData)
}
context.orderItemDatas = orderItemDatas.values()

// Handle any item product quantities to receive by adding to the map in session
productIdToReceive = request.getParameter("productId")
productQtyToReceive = request.getParameter("quantity")
context.newQuantity = productQtyToReceive

if (productIdToReceive) {
    List candidateOrderItems = EntityUtil.filterByAnd(orderItems, [productId : productIdToReceive])

    // If the productId as given isn't found in the order, try any goodIdentifications and use the first match
    if (!candidateOrderItems) {
        goodIdentifications = from("GoodIdentification").where("idValue", productIdToReceive).queryList()
        if (goodIdentifications) {
            giit = goodIdentifications.iterator()
            while (giit.hasNext()) {
                goodIdentification = giit.next()
                candidateOrderItems = EntityUtil.filterByAnd(orderItems, [productId : goodIdentification.productId])
                if (candidateOrderItems) {
                    productIdToReceive = goodIdentification.productId
                    break
                }
            }
        }
    }

    if (candidateOrderItems) {
        quantity = 0
        if (productQtyToReceive) {
            try {
                quantity = Double.parseDouble(productQtyToReceive)
            } catch (Exception e) {
                // Ignore the quantity update if there's a problem parsing it
            }
        }

        totalQuantityUsed = 0
        totalQuantityToReceiveBefore = 0
        pqit = candidateOrderItems.iterator()
        while (pqit.hasNext() && totalQuantityUsed < quantity) {
            candidateOrderItem = pqit.next()
            orderItemSeqId = candidateOrderItem.orderItemSeqId
            qtyBefore = itemQuantitiesToReceive.containsKey(orderItemSeqId) ? itemQuantitiesToReceive.get(orderItemSeqId) : 0
            totalQuantityToReceiveBefore += qtyBefore
            qtyMaxAvailable = orderItemDatas.get(orderItemSeqId).availableToReceive - qtyBefore

            if (qtyMaxAvailable <= 0) {
                continue
            }

            qtyUsedForItem  = quantity - totalQuantityUsed >= qtyMaxAvailable ? qtyMaxAvailable : quantity - totalQuantityUsed
            itemQuantitiesToReceive.put(orderItemSeqId, qtyUsedForItem + qtyBefore)
            totalQuantityUsed += qtyUsedForItem
        }

        // If there's any quantity to receive left after using as much as possible for every relevant order item, add an error message to the context
        if (quantity > totalQuantityUsed) {
            context.ProductReceiveInventoryAgainstPurchaseOrderQuantityExceedsAvailableToReceive = true
        }

        // Notify if some or all of the quantity just entered for the product will go to a backorder
        backOrderedQuantity = orderItemDatas.get(EntityUtil.getFirst(candidateOrderItems).orderItemSeqId).backOrderedQuantity - totalQuantityToReceiveBefore

        if (backOrderedQuantity > 0) {
            totalQtyUsedForBackorders = backOrderedQuantity >= totalQuantityUsed ? totalQuantityUsed : backOrderedQuantity
            if (totalQtyUsedForBackorders > 0) {
                context.quantityToReceive = totalQuantityUsed
                context.quantityToBackOrder = totalQtyUsedForBackorders
                context.ProductReceiveInventoryAgainstPurchaseOrderQuantityGoesToBackOrder = true
            }
        }
    } else {

        // Add an error message to the context if the productId doesn't exist in this purchase order
        context.ProductReceiveInventoryAgainstPurchaseOrderProductNotFound = true
    }
}

// Put the tracking map back into the session, in case it has been reconstructed
session.setAttribute("purchaseOrderItemQuantitiesToReceive", itemQuantitiesToReceive)
context.itemQuantitiesToReceive = itemQuantitiesToReceive
context.totalAvailableToReceive = totalAvailableToReceive