<?php

namespace App\Services;

use App\OracleActAllocationDetails;
use App\OracleDOCOrderDetail;
use App\OracleDOCOrderHeader;
use App\Order;
use App\OrderPackage;
use App\OrderPackageCommodities;
use App\Services\common\BatchUpdateService;
use Carbon\Carbon;

class OrderPackageService
{
    public function batchUpdate(array $params){
        return app(BatchUpdateService::class)->batchUpdate('order_packages',$params);
    }

    public function insert(array $params)
    {
        return OrderPackage::query()->insert($params);
    }

    public function createdByOrder($order)
    {
        /** @var OrderPackageCommoditiesService $orderPackageCommoditiesService */
        $orderPackageCommoditiesService = app('orderPackageCommoditiesService');
        $oracleActAllocationDetails = OracleActAllocationDetails::query()->where('OrderNo', $order['code'])->get();
        $orderHeader = OracleDOCOrderHeader::query()->where('OrderNo', $order['code'])->first();
        $oracleDOCOrderDetail = OracleDOCOrderDetail::query()->where('OrderNo', $order['code'])->get();
        $logistic_number = null;
        if ($oracleActAllocationDetails->count() == 0) {  // 通过oracle Order Detail
            $logistic_number = $orderHeader['soreference5'];
            if ($oracleDOCOrderDetail->count() == 0) {
                return null;
            }
            if ($logistic_number == null || $logistic_number == '*') {
                return null;
            }
            try {
                $orderPackage = OrderPackage::query()->firstOrCreate(['order_id' => $order['id'], 'logistic_number' => $logistic_number]);
                $orderPackageCommoditiesService->basedOnOracleDetailsStore($orderHeader['orderno'], $orderPackage);
                LogService::log(__METHOD__, __FUNCTION__, '创建订单包裹orderPackage' . json_encode($orderPackage));
            } catch (\Exception $e) {
                LogService::log(__METHOD__, __FUNCTION__, '创建订单包裹orderPackage失败' . $e->getMessage() . $e->getTraceAsString());
            }
        } else if ($oracleActAllocationDetails->count() > 0) {
            $count = $oracleActAllocationDetails->where('OrderNo', $order['code'])->whereNull('picktotraceid')->count();
            if ($count > 0) {   // 快递单号为空
                if (($orderHeader['soreference5'] ?? false) && $orderHeader['soreference5'] == '*') {
                    return null;
                }
                $logistic_number = $orderHeader['soreference5'];

                try {
                    $orderPackage = OrderPackage::query()->firstOrCreate(['order_id' => $order['id'], 'logistic_number' => $logistic_number]);
                    $orderPackageCommoditiesService->basedOnOracleDetailsStore($order, $orderPackage);
                    LogService::log(__METHOD__, __FUNCTION__, '创建订单包裹orderPackage' . json_encode($orderPackage));
                } catch (\Exception $e) {
                    LogService::log(__METHOD__, __FUNCTION__, '创建订单包裹orderPackage失败' . $e->getMessage() . $e->getTraceAsString());
                }
            } else {
                $ActAllocationDetails = $oracleActAllocationDetails->where('orderno', $order['code']);
                $picktotraceids = data_get($ActAllocationDetails,'*.picktotraceid');
                $picktotraceids = array_unique($picktotraceids);
                foreach ($picktotraceids as $picktotraceid) {
                    $logistic_number = $picktotraceid;
                    if ($logistic_number == null || $logistic_number == '*') {
                        $logistic_number = $orderHeader['soreference5'];
                        if ($logistic_number == null || $logistic_number == '*') {
                            return null;
                        }
                        $orderPackage = OrderPackage::query()->where(['order_id' => $order['id'], 'logistic_number' => $logistic_number])->first();
                        if ($orderPackage) {
                            $orderPackageCommoditiesService->basedOnActAllocationDetailsStoreByOrderNo($order['code'], $orderPackage);
                            continue;
                        }
                        try {
                            $orderPackage = OrderPackage::query()->create(['order_id' => $order['id'], 'logistic_number' => $logistic_number]);
                            $orderPackageCommoditiesService->basedOnActAllocationDetailsStoreByOrderNo($order['code'], $orderPackage);
                            LogService::log(__METHOD__, __FUNCTION__, '创建订单orderPackage' . json_encode($orderPackage));
                        } catch (\Exception $e) {
                            LogService::log(__METHOD__, __FUNCTION__, '创建订单orderPackage失败' . json_encode($e->getMessage()) . json_encode($e->getTraceAsString()));
                        }
                        continue;
                    }
                    $orderPackage = OrderPackage::query()->where('order_id', $order['id'])->where('logistic_number', $logistic_number)->first();
                    if ($orderPackage) {
                        $orderPackageCommoditiesService->basedOnActAllocationDetailsStore($orderPackage);
                        continue;
                    }
                    try {
                        $orderPackage = OrderPackage::query()->create(['order_id' => $order['id'], 'logistic_number' => $logistic_number]);
                        $orderPackageCommoditiesService->basedOnActAllocationDetailsStore($orderPackage);
                        LogService::log(__METHOD__, __FUNCTION__, '创建订单' . json_encode($orderPackage));
                    } catch (\Exception $e) {
                        LogService::log(__METHOD__, __FUNCTION__, '创建订单orderPackage失败' . json_encode($e->getMessage()) . json_encode($e->getTraceAsString()));
                    }
                }
            }
        }
        unset($oracleActAllocationDetails,$oracleDOCOrderDetail);
    }

    public function updateOrderPackageInfo(Order $order)
    {
        $orderHeader = OracleDOCOrderHeader::where('orderNo', $order['code'])->first();
        if ($orderHeader['oracleBASCode_codename_c'] == $order['wam_status']) {
            return;
        }
        $orderPackages = OrderPackage::where('order_id', $order['id'])->get();
        $orderPackageCommodities = OrderPackageCommodities::with('commodity')->whereIn('order_package_id', data_get($orderPackages, '*.id'))->get();
        $actAllocationDetails = OracleActAllocationDetails::where('orderNo', $order['client_code'])->get();
        if (count($orderPackageCommodities) < count($actAllocationDetails)) {
            $actAllocationDetails = $actAllocationDetails->reject(function ($value, $key) use (&$orderPackageCommodities) {
                $bool = false;
                $count = 0;
                $orderPackageCommodities->reject(function ($value1, $key1) use ($value, &$bool, $count) {
                    if ($count > 0) {
                        return false;
                    }
                    if ($value1->commodity['sku'] == $value['sku'] && $value1['amount'] == intval($value['qty'])) {
                        $bool = true;
                        $count++;
                        return true;
                    } else {
                        return false;
                    }
                });
                return $bool;
            });
        }
        $orderPackageCommoditiesService = app('orderPackageCommoditiesService');
        $orderPackageCommoditiesService->basedOnActAllocationDetail($order, $orderHeader, $actAllocationDetails);
        $order['wam_status'] = $orderHeader['oracleBASCode_codename_c'];
        $order->save();
    }
    /**
     * @param string $logistic_number
     * @param array $values
     * @return OrderPackage $package
     */
    public function firstOrCreate($logistic_number, array $values){
        /** @var $package OrderPackage  */
        $package = OrderPackage::query()->where('logistic_number',$logistic_number)->first();
        if ($package)return $package;

        /** @var OrderService */
        $order = app('orderService')->logisticNumberCreateOrder($logistic_number);
        if ($order) $values["order_id"] = $order->id;

        $values["logistic_number"] = $logistic_number;
        /** @var OrderPackage $package */
        $package = OrderPackage::query()->create($values);
        return $package;
    }


    public function createExceptionPaginate($paginate)
    {
        return OrderPackage::query()->select('id', 'status', 'logistic_number', 'measuring_machine_id', 'weighed_at', 'weight', 'length', 'width', 'height', 'bulk', 'paper_box_id')
            ->where('status', '上传异常')->orWhere('status', '测量异常')->orderBy('created_at', 'DESC')
            ->paginate($paginate);
    }

    public function issueExceptionPaginate($paginate)
    {
        return OrderPackage::query()->select('id', 'logistic_number', 'created_at', 'batch_number', 'batch_rule')
            ->where('status', '下发异常')->orWhere('status', '记录异常')
            ->orWhere('status', '已上传异常')->orderBy('created_at', 'DESC')
            ->paginate($paginate);
    }


    public function 根据WMS订单创建WAS包裹($orderHeaders, $orders)
    {
        $orderPackagesFillables = [];
        foreach ($orders as $order) {
            $orderHeader = $orderHeaders[strval($order['code'])] ?? false;
            if(!$orderHeader){
                continue;
            }
            $fillables = $this->根据WMS订单生成包裹信息($orderHeader, $order);
            foreach ($fillables as $fillable) {
                $orderPackagesFillables[] = $fillable;
            }
        }
        try {
            if(count($orderPackagesFillables) > 0){
                OrderPackage::query()->insert($orderPackagesFillables);
                LogService::log(__METHOD__, __FUNCTION__, '批量订单包裹信息' .count($orderPackagesFillables). json_encode($orderPackagesFillables) );
            }
        } catch (\Exception $e) {
            LogService::log(__METHOD__, __FUNCTION__, '批量订单包裹信息 error' .json_encode($orderPackagesFillables) .  $e->getMessage().$e->getTraceAsString());
        } finally {
            $order_ids = data_get($orders,'*.id');
            unset($orderPackagesFillables,$orders,$fillables);
            return Order::query()->with('packages')->whereIn('id',$order_ids)->get();
        }
    }

    public function 根据WMS订单生成包裹信息($orderHeader, $order)
    {

        $soReference5 = $orderHeader['soreference5'];
        $orderPackages= [];
        $logistic_numbers = [];

        foreach ($orderHeader['actAllocationDetails'] as $actAllocationDetail) {
            $logistic_numbers[]  =$actAllocationDetail->picktotraceid;
            array_push($logistic_numbers,$actAllocationDetail['picktotraceid']);
        }

        $logistic_numbers = array_unique($logistic_numbers);
        $logistic_numbers = array_diff($logistic_numbers,['','*',null]);

        $logistic_numbers = count($logistic_numbers) == 0 ? ($soReference5 != '*' ? [$soReference5] : []) : $logistic_numbers;
        $logistic_numbers = array_diff($logistic_numbers,['','*',null]);

        if(count($logistic_numbers) == 0 ){ return  [];}

        if (count($logistic_numbers) != 0) {
            foreach ($logistic_numbers as $logistic_number) {
                $fillable = [
                    'order_id' => $order['id'],
                    'logistic_number' => $logistic_number,
                ];
                $orderPackages[] = $fillable;
            }
        }
        return $orderPackages;
    }

    public function 更新WAS订单的包裹的重量和体积($orderHeaders,$orderPackages)
    {

        /** @var CommodityService $commodityService */
        $commodityService = app('commodityService');
        $commodities = $commodityService->getWASCommoditiesByWMSOrderHeaders($orderHeaders); // 商品


        $multipleData = [['id','weight','bulk']];
        $noAttributeCommodity = [];

        $commodity_map = [];
        foreach ($commodities as $commodity) {
            $key = ' id='.$commodity->id;
            $commodity_map[$key] = $commodity;
        }
        foreach ($orderPackages as $packages) {
            foreach ($packages as $package) {

                if($package == null){
                    continue;
                }
                $orderPackageCommodities = $package['commodities'] ?? [];
                $updateArr = [
                    'id' => $package['id'],
                    'weight' => 0,
                    'bulk' => 0,
                ];
                foreach ($orderPackageCommodities as $packageCommodity) {
                    $commodity =  $commodity_map[' id='.$packageCommodity->commodity_id];
                    if($commodity['weight'] == 0  || !$commodity['bulk'] == 0 ){
                        array_push($noAttributeCommodity,$commodity);
                    }
                    $updateArr['weight'] += bcmul($commodity['weight'], $packageCommodity['amount'],5);
                    $updateArr['bulk'] += bcmul($commodity['bulk'], $packageCommodity['amount'],5);
                    //$updateArr['weight'] +=(intval($commodity['weight'] ?? 0) )  * ( intval($packageCommodity['amount'] ?? 0) );
                    //$updateArr['bulk'] += (intval($commodity['bulk']  ?? 0)) * (intval($packageCommodity['amount'] ?? 0) );
                }
                if($package['weight'] == $updateArr['weight'] && $package['bulk'] == $updateArr['bulk']){
                    continue;
                }
                // 订单同步步时 重量 体积不覆盖已有值
                if($packages['weight'] ?? false){
                    $updateArr['weight'] = $packages['weight'];
                }
                if($packages['bulk'] ?? false){
                    $updateArr['bulk'] = $packages['bulk'];
                }
                $multipleData[] = $updateArr;
            }
        }
        if(count($multipleData) > 1){
            /** @var BatchUpdateService $batchUpdateService */
            $batchUpdateService = app('batchUpdateService');
            $batchUpdateService->batchUpdate('order_packages',$multipleData);
        }
        array_unique($noAttributeCommodity);
        if(count($noAttributeCommodity) > 1){
            $commodityService->syncCommodityAttribute($noAttributeCommodity);
        }
        unset($multipleData,$noAttributeCommodity,$commodities);
    }

    public function 更新WAS订单快递单号信息($orderHeaders,$orders)
    {

        $fillables = [];
        $orders_map = [];
        $orders_package_map = [];
        foreach ($orders as $order){
            $key = $order['code'];
            $orders_map[$key] = $order;
            foreach ($order['packages'] as $package) {
                $logistic_numbers = $package['logistic_number'];
                $orders_package_map[$key][$logistic_numbers] =$package;
            }
        }

        foreach ($orderHeaders as $key=>$orderHeader) {
            $order = $orders[$key] ?? false;
            if(!$order){
                continue;
            }
            $packages = $orders_package_map[$key] ?? false;
            $pickToTraceIds = [];
            foreach ($orderHeader->actAllocationDetails as $actAllocationDetail) {
                $pickToTraceIds[] = $actAllocationDetail['picktotraceid'];
            }
            $pickToTraceIds = array_unique(array_diff($pickToTraceIds,['','*',null]));

            foreach ($pickToTraceIds as $pickToTraceId) {
                if(!$packages || !($orders_package_map[$key][$pickToTraceId] ?? false)){
                    $fillables[] = [
                        'order_id' => $order->id,
                        'logistic_number' => $pickToTraceId
                    ];
                }
            }
        }

        try {
            if(count($fillables)>0){
                OrderPackage::query()->insert($fillables);
                LogService::log(__METHOD__,__FUNCTION__,'创建orderPackage:'.json_encode($fillables));
            }
        } catch (\Exception $e) {
            LogService::log(__METHOD__,__FUNCTION__,'创建orderPackage 失败:'.json_encode($fillables).$e->getMessage().$e->getTraceAsString());
        } finally {
            unset($fillables);
        }
    }

    public function createByWmsOrder($orderHeaders_map)
    {
        if(!$orderHeaders_map ){return [];}
        /** @var OrderService $orderService */
        $orderService = app(OrderService::class);
        $orders = $orderService->getByWmsOrders($orderHeaders_map);
        if(!$orders){return [];}
        $orders_code_map = [];
        foreach ($orders as $order) {
            $orders_code_map[$order->code] = $order;
        }

        $order_packages_logistic_number_map = [];
        $order_packages = OrderPackage::query()->whereIn('order_id',data_get($orders,'*.id'))->get();

        foreach ($order_packages as $order_package) {
//            $key = ' order_id='.$order_package->order_id.' logistic_number='.$order_package->logistic_number;
            $key = ' logistic_number='.$order_package->logistic_number;
            $order_packages_logistic_number_map[$key] = $order_package;
        }

        $insert_params = [];
        foreach ($orders_code_map as $key=>$order) {
            $orderHeader = $orderHeaders_map[$key];
            if(!$orderHeader){ continue;}
            $params = $this->getParamsByOrderHeader($orderHeader,$order,$order_packages_logistic_number_map);
            if(!$params){continue;}
            $insert_params = array_merge($insert_params,$params);
        }
        if(count($insert_params) ==  0){return null;}
        $order_packages = $this->create($insert_params);
        /** @var OrderPackageCommoditiesService $orderPackageCommodityService */
        /** @var OwnerService  $ownerService */
        /** @var CommodityService  $commodityService */
        $orderPackageCommodityService = app(OrderPackageCommoditiesService::class);
        $ownerService = app(OwnerService::class);
        $commodityService = app(CommodityService::class);
        $owner_code_map = [];

        $commodities = $commodityService->getByWmsOrders($orderHeaders_map);

        $owners = $ownerService->getByWmsOrders($orderHeaders_map);
        foreach ($owners as $owner) {
            $owner_code_map[$owner->code] = $owner;
        }
        $order_package_commodities = $orderPackageCommodityService->createByWmsOrder($orderHeaders_map,$order_packages,$owner_code_map,$commodities);
        unset($orderHeaders_map,$orders_code_map,$fillables,$order_packages_logistic_number_map);
        $this->updateWeightAndBulk($order_packages,$order_package_commodities);
        unset($order_packages,$order_package_commodities);
    }


    public function getParamsByOrderHeader($orderHeader,$order,$order_packages_logistic_number_map){
        $actAllocationDetails = $orderHeader->actAllocationDetails;
        $logistic_numbers = array_diff(array_unique(data_get($actAllocationDetails,'*.picktotraceid')),['','*',null]);
        $params = [];
        $created_at = Carbon::now()->format('Y-m-d H:i:s');;
        foreach ($logistic_numbers as $logistic_number) {
            $map_key = ' order_id='.$order->id.' logistic_number='.$logistic_number;
            if(isset($order_packages_logistic_number_map[$map_key])){ continue;}
            $params[] = [
                'order_id' => $order->id, 'logistic_number' => $logistic_number,'created_at' => $created_at
            ];
        }
        $oracleDOCOrderDetails = $orderHeader->oracleDOCOrderDetails;
        if(count($logistic_numbers) === 0 && count($oracleDOCOrderDetails) > 0){
            $key = ' logistic_number='.$orderHeader->soreference5;
            if(!isset($orderHeader->soreference5) || in_array($orderHeader->soreference5,[''.'*',null])){return $params;}
            if(!isset($order_packages_logistic_number_map[$key])){
                $params[] = [
                    'order_id' => $order->id, 'logistic_number' => $orderHeader->soreference5,'created_at' => $created_at
                ];
            }
        }
        return $params;
    }

    public function updateWeightAndBulk($orderPackages,$orderPackageCommodities){
        if(!$orderPackageCommodities){return ;}
        if(!$orderPackages){return ;}
        $orderPackageCommodities_map =[];
        foreach ($orderPackageCommodities as $orderPackageCommodity) {
            $order_package_id = $orderPackageCommodity->order_package_id;
            if(!isset($orderPackageCommodities_map[$order_package_id])){
                $orderPackageCommodities_map[$order_package_id]= [];
            }
            $orderPackageCommodities_map[$order_package_id][] = $orderPackageCommodity;
        }

        $update_params = [['id','bulk','updated_at']];
        $updated_at = Carbon::now()->format('Y-m-d H:i:s');
        foreach ($orderPackages as $orderPackage) {
            $order_package_id = $orderPackage->id;
            $orderPackageCommodity_list = $orderPackageCommodities_map[$order_package_id] ?? [];
            if(!$orderPackageCommodity_list){continue;}
            if( isset($orderPackage['bulk']) && $orderPackage['bulk']!=0){
                continue;
            }
            $params = ['id'=>$order_package_id,'bulk' => null,'updated_at'=>$updated_at];
            foreach ($orderPackageCommodity_list as $orderPackageCommodity) {
                $commodity = $orderPackageCommodity->commodity;
                if(!$commodity['length'] || !$commodity['width'] || !$commodity['height']){
                    continue;
                }
                $bulk = bcmul($commodity['length'],$commodity['width'],5);
                $bulk = bcmul($commodity['height'],$bulk,5);
                $bulk = bcmul($bulk,$orderPackageCommodity->amount,5);
                $params['bulk'] +=  $bulk;
            }
            if($params['bulk'] == $orderPackage->bulk && $orderPackage->bulk!= 0){continue;}
            $update_params[]= $params;
        }
        if(count($update_params) > 1){
            $this->batchUpdate($update_params);
        }
    }

    public function updateOrderPackageByWmsOrder($orderHeaders){
        /** @var OrderPackageCommoditiesService $orderPackageCommoditiesService */
        $orderPackageCommoditiesService =  app(OrderPackageCommoditiesService::class);
        if(!$orderHeaders){return;}

        $order_nos = data_get($orderHeaders,'*.orderno');
        $orders = Order::query()->with('packages')->whereIn('code',$order_nos)->get();

        $orders_code_map = [];
        $order_packages_logistic_number_map = [];
        foreach ($orders as $order) {
            $orders_code_map[$order->code] = $order;
            $order_packages = $order->packages;
            if(!$order_packages){continue;}
            foreach ($order_packages as $order_package) {
                $key = ' order_id='.$order->id.' logistic_number='.$order_package->logistic_number;
                $order_packages_logistic_number_map[$key] =$order_package;
            }
        }


        $insertParams = [];
        foreach ($orderHeaders as $orderHeader) {
            $order = $orders_code_map[$orderHeader->orderno] ?? false;
            if(!$order){continue;}
            $order_packages = $order->packages;
            if(!$order_packages){continue;}
            $params =$this->getParamsByOrderHeader($orderHeader,$order,$order_packages_logistic_number_map);
            if(count($params) > 0){
                foreach ($params as $param) {
                    $key = ' order_id='.$param['order_id'].' logistic_number='.$param['logistic_number'];
                    $order_package =  $order_packages_logistic_number_map[$key] ?? false;
//                    $order_package =  $order_packages_logistic_number_map[$param['logistic_number']] ?? false;
//                    $order_package = $order_packages->where('logistic_number',$param)->first();
                    if($order_package){continue;}
                    $insertParams[] = $param;
                }
            }
        }
        if(count($insertParams)>0){
            $this->insert($insertParams);
        }

        $orderPackageCommoditiesService->updateByWmsOrder($orderHeaders);
        $order_packages = OrderPackage::query()->with('order')
            ->whereHas('order',function($query) use($order_nos){
                $query->whereIn('code',$order_nos);
            })->get();

        $order_package_ids = data_get($order_packages,'*.id');
        $order_package_commodities = OrderPackageCommodities::query()
            ->with('package')
            ->whereHas('package',function($query) use ($order_package_ids){
                $query->whereIn('id',$order_package_ids);
            })->get();
        $this->updateWeightAndBulk($order_packages,$order_package_commodities);
    }

    public function getLogisticNumbersByOrderHeader($orderHeader){
       $oracleDOCOrderDetails =  $orderHeader->oracleDOCOrderDetails;
       $actAllocationDetails = $orderHeader->actAllocationDetails;
       if($actAllocationDetails){
            $logistic_numbers = data_get($actAllocationDetails,'*.picktotraceid');
            return array_diff(array_unique($logistic_numbers),['','*',null]);
       }
       if($oracleDOCOrderDetails){
           return [$orderHeader->soreference5];
       }
       return [];
    }

    public function getByWmsOrders($orderHeaders){
        $order_nos = data_get($orderHeaders,'*.orderno');
        return OrderPackage::query()->with('order')
            ->whereHas('order',function($query) use ($order_nos){
                $query->whereIn('code',$order_nos);
            })->get();
    }

    public function create(array $params)
    {
        if(count($params) == 0)return null;
        try {
            $this->insert($params);
            LogService::log(__METHOD__,__FUNCTION__,'批量生成 orderPackage' . count($params) . json_encode($params));
        } catch (\Exception $e) {
            LogService::log(__METHOD__,__FUNCTION__,'批量生成 orderPackage error ' . json_encode($params) . $e->getMessage() . $e->getTraceAsString());
        } finally {
            $logistic_numbers = data_get($params,'*.logistic_number');
            unset($params);
            return OrderPackage::query()->whereIn('logistic_number',$logistic_numbers)->get();
        }
    }
}