<?php

namespace App\Services\Order;

use App\Http\Requests\Order\AddToCartRequest;
use App\Http\Requests\Order\CreateRequest;
use App\Http\Requests\Order\IndexRequest;
use App\Http\Requests\Order\UpdateRequest;
use App\Models\Branch;
use App\Models\Order;
use App\Models\Service\Service;
use App\Models\Shipment;
use App\Repository\Order\OrderRepository;
use App\Repository\Part\PartRepository;
use App\Services\ImportService;
use App\Services\Shipment\ShipmentService;
use App\Services\Status\StatusService;
use App\Traits\Stat;
use Illuminate\Database\Eloquent\Collection;

class OrderService
{

    use Stat;

    /** @var OrderRepository */
    protected static OrderRepository $repository;

    protected OrderRepository $rep;

    public static function setRepository()
    {
        self::$repository = new OrderRepository();
    }

    /**
     * OrderService constructor.
     */
    public function __construct()
    {
        self::setRepository();

        $this->rep = new OrderRepository();
    }

    /**
     * @return OrderRepository
     */
    public static function getRepository()
    {
        self::setRepository();

        return self::$repository;
    }

    public function search(IndexRequest $request)
    {
        return $this->rep->search($request);
    }

    /**
     * @param $id
     *
     * @return mixed
     */
    public static function getById($id)
    {
        return OrderRepository::getAvailableOrders()->findOrFail($id);
    }

    public static function getAvailable()
    {
        return self::getRepository()::getAvailableOrders();
    }

    public function save(CreateRequest $request)
    {
        return self::$repository->save($request);
    }

    public static function save1c($item)
    {
        return OrderRepository::save1c($item);
    }

    public function count()
    {
        return self::$repository->count();
    }

    public function part($part_id)
    {
        return self::$repository->part($part_id);
    }

    public function addToCart($part_id, $amount)
    {
        self::$repository->addToCart($part_id, $amount);
    }

    public function deleteOneFromCart(AddToCartRequest $request)
    {
        self::$repository->deleteOneFromCart($request);
    }

    public function getParts()
    {
        return self::$repository->getParts();
    }

    public function update(UpdateRequest $request)
    {
        self::$repository->update($request);
    }

    public static function update1c($item)
    {
        return OrderRepository::update1c($item);
    }

    public static function getAvailableByStatus($id)
    {
        return self::getRepository()::getAvailableByStatus($id)->first();
    }

    public static function getAvailableOpenedOrders($repair_id)
    {
        return self::getRepository()::getAvailableOpenedOrders($repair_id)->get();
    }

    public function addToCartFromCsv($id, $amount)
    {
//        $res = $this->saveFromCsv($file, ';');
//        if(isset($res['errors']) && $res['errors'] == 'wrongFile')
//            return $this->saveFromCsv($file, ',');
//        else return $res;

        $this->rep->addToCart($id, $amount);
    }

    public function saveFromCsv($file, $delimiter)
    {
        $success = 0;
        $errors = [];
        $undefined = [];

        if (($handle = fopen($file, 'r')) !== FALSE) {
            while (($data = fgetcsv($handle, 0, $delimiter, '"')) !== FALSE) {
                if (!isset($data[0]) || !isset($data[1])) {
                    return ['errors' => 'wrongFile'];
                } elseif (isset($data[0]) && $data[0] && isset($data[1]) && $data[1] && $data[1] != 0) {
                    //  $data[0] = iconv(mb_detect_encoding($data[0]),'UTF-8',$data[0]);
                    $part = PartRepository::searchByName(trim($data[0]));
                    if ($part && count($part) == 1) {
                        $success++;
                        $this->rep->addToCart($part[0]->id, (int) $data[1]);
                    } elseif ($part && count($part) > 1) {
                        array_push($undefined, $data);
                    } else {
                        array_push($errors, $data);
                    }
                }
            }
            fclose($handle);
        }

        return ['errors' => $errors, 'success' => $success, 'undefined' => $undefined];
    }


    public function getLast()
    {
        return self::$repository->getLast()->get();
    }

    public function getStats($start, $end)
    {
        $statuses = StatusService::getOrderAll();

        $query = self::getRepository()::getAvailableOrders();

        $query
            ->where('created_at', '>=', $start . ' 00:00:00')
            ->where('created_at', '<=', $end . ' 23:59:59');

        return $this->countBySatuses($statuses, $query);
    }

    public static function lockOrders($ids)
    {
        Order::whereIn('id', $ids)
            ->update(['is_editable' => 0]);
    }

    public static function unLockOrders($ids)
    {
        Order::whereIn('id', $ids)
            ->update(['is_editable' => 1]);
    }

    public static function formatOrdersForReceiver(Collection $data)
    {
        $result_data = [];

        $ids = $data->keys();
        self::lockOrders($ids);

        foreach ($data as $item) {
            /** @var Order $item */
            $parts = [];

            foreach ($item->order_items as $order_item) {
                array_push($parts, ['code' => $order_item->part_external_id, 'quantity' => $order_item->amount]);
            }

            if (empty($item->service) || empty($item->branch)) {
                continue;
            }

            $result_data[$item->id] = [
                'crm_id' => $item->id,
                'code' => $item->code,
                'created_at' => $item->created_at->format('d.m.Y H:i:s'),
                'action' => ($item->exernal_id) ? 'updated' : 'new',
                'service_code' => $item->service->external_id,
                'branch_code' => $item->branch->external_id,
                'status' => $item->status,
                'created_by_manager' => $item->created_by_manager,
                'type' => $item->repair,
                'additional_info' => $item->additional_info,
                'invoice' => '',
                'parts' => $parts,
            ];

            if (!empty($item->shipment->items)) {
                $shipmentData = $item->shipment[0];
                $result_data[$item->id]['track_number'] = $shipmentData->track_number;
                $result_data[$item->id]['post_type'] = $shipmentData->delivery_service;
            } else {
                $result_data[$item->id]['track_number'] = '';
                $result_data[$item->id]['post_type'] = '';
            }
        }

        return $result_data;
    }

    protected static function formattingData($order): array
    {
        $branchCode = trim((string) $order->branch_code);
        $branch = Branch::where('external_id', $branchCode)->withTrashed()->first();

        if (empty($branch)) {
            echo 'Unknown branch ' . $branchCode . ' - skip' . PHP_EOL;

            return [];
        }
        $serviceCode = trim((string) $order->service_code);
        $service = Service::where('external_id', $serviceCode)->withTrashed()->first();
        if (empty($service)) {
            echo 'Unknown service ' . $serviceCode . ' - skip' . PHP_EOL;

            return [];
        }
        $data = [
            'id' => (int) $order->crm_id,
            'external_id' => (string) $order->code,
            'created_at' => (string) $order->created_at,
            'service_id' => $service->id,
            'branch_id' => $branch->id,
            'action' => (string) $order->action,
            'status' => (string) $order->status,
            'created_by_manager' => (string) $order->created_by_manager,
            'type' => (string) $order->type,
            'invoice' => (string) $order->invoice,
            'additional_info' => trim($order->additional_info),
            'track_number' => (string) $order->track_number,
            'post_type' => (string) $order->post_type,
        ];

        $parts = [];
        foreach ($order->parts->part as $part) {
            $parts[] = [
                'code' => trim((string) $part->code),
                'quantity' => (int) $part->quantity,
            ];
        }

        array_walk($data, function (&$value) {
            $value = trim($value);
        });

        $data['parts'] = $parts;

        return $data;
    }

    public static function import($orderData): array
    {
        $crm_id = 0;
        $result = 0;

        $action = $orderData['action'];
        $createdAt = $orderData['created_at'];
        $externalId = $orderData['code'];

        echo 'Действие: ' . $action . PHP_EOL;
        switch ($action) {
            case ImportService::NEW:
            case ImportService::UPDATE:
            case 'новый':
            case 'изменен':
                if (empty($orderData['id'])) {
                    /** @var ?Order $order */
                    $order = OrderRepository::getBy1sKey($externalId, date('Y', strtotime($createdAt)), true);
                    if (empty($order)) {
                        echo '- Создание из создания', PHP_EOL;
                        $response = self::save1c($orderData);
                    } else {
                        echo '- Обновление из создания', PHP_EOL;
                        $response = self::update1c($orderData);
                    }
                } else {
                    $order = Order::query()->where('id', $orderData['id'])->withTrashed()->first();
                    if (!empty($order)) {
                        echo '- Обновление', PHP_EOL;
                        $response = self::update1c($orderData);
                    }
                }

                $crm_id = $response['order_id'] ?? 0;
                $result = $response['result'] ?? 1;

                $trackNumber = $orderData['track_number'];
                $postType = $orderData['post_type'];

                // TODO Протестить
                if (!empty($trackNumber) && !empty($postType)) {
                    $shipment = Shipment::query()->where('order_id', $crm_id)->first();
                    if (!$shipment) {
                        $res_shipment = ShipmentService::save1c($orderData);
                    }
                }

                break;
            default:
                echo 'Неизвестное действие ' . $action . PHP_EOL;
        }

        return ['code' => $orderData['code'], 'crm_id' => $crm_id, 'result' => $result];
    }

}