<?php

namespace App\Services\Service;

use App\Http\Requests\Service\IndexServiceRequest;
use App\Http\Requests\Service\UpdateServiceRequest;
use App\Models\Repair\Repair;
use App\Models\RepairPrice;
use App\Models\Service\Service;
use App\Models\ServicePrice;
use App\Repository\Address\AddressRepository;
use App\Repository\Device\DeviceRepository;
use App\Repository\Service\ServiceRepository;
use App\Services\Address\AddressService;
use App\Services\Branch\BranchService;
use App\Services\User\UserService;
use App\User;


class ServiceService
{

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

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

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

        return self::$repository;
    }

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

    /**
     * @param $id
     *
     * @return mixed
     */
    public static function getById($id)
    {
        return self::getRepository()::getById($id);
    }

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

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

    public function delete($id)
    {
        self::getRepository()->delete($id);
    }

    public function deleteByBranch($id)
    {
        $items = self::getRepository()::getAvailable()->where(['branch_id' => $id])->get('id');
        foreach ($items as $item) {
            self::getRepository()->delete($item->id);
        }
    }

    /**
     * @param IndexServiceRequest $request
     *
     * @return mixed
     */
    public function search(IndexServiceRequest $request)
    {
        return self::getRepository()->search($request);
    }

    /**
     * Return active items available for me, and filtered by Branch converted for ajax select
     *
     * @param $type = 'inline', 'avail' = use getAvailable()
     *
     * @return array
     */
    public static function getByBranchAjax($branchIds = [], $search = null, $type = null)
    {
        $query = ServiceRepository::getByBranch($branchIds, $type);
        if ($search) {
            $query->where('name', 'like', '%' . $search . '%');
        }

        if (substr_count($type, 'inline')) {
            return $query->get()->pluck('name', 'id')->toArray();
        } else {
            return $query->get(['name as text', 'id'])->toArray();
        }
    }

    public static function getAddress($service_id)
    {
        return AddressRepository::getByServiceId($service_id)->get()->pluck('full_address')->toArray();
    }

    public static function getSimpleAddress($service_id)
    {
        return AddressRepository::getByServiceId($service_id)->get()->pluck('full_simple_address', 'id')->toArray();
    }

    public static function savePriceFromCsv($service, $data)
    {
        $categories = Repair::getCategories();
        $name = trim($data[0]);

        $enc = mb_detect_encoding($name);
        if ($enc && $enc <> 'UTF-8') {
            $name = iconv($enc, 'UTF-8//IGNORE', $name);
        }

        $price = trim($data[1]);
        $price = str_replace(',', '.', $price);
        $price = (float) $price;
        if ($key = array_search($name, $categories)) {
            ServicePrice::updateOrCreate(
                ['service_id' => $service->id, 'category_id' => $key],
                ['price' => $price,]
            );

            return 'success';
        }

        return 'category_not_found';
    }

    public static function getPrices(int $serviceId): array
    {
        $data = [['Артикул', 'ТМЦ', 'Ремонт 1 категории', 'Ремонт 2 категории', 'Ремонт 3 категории']];

        $prices = RepairPrice::query()->where('service_id', $serviceId)->get();
        foreach ($prices as $price) {
            $device = DeviceRepository::getByExternalId($price->device_external_id);
            $data[] = [
                $price->device_external_id ?? '',
                $device->name ?? '',
                $price->repair_category_1 ?? '',
                $price->repair_category_2 ?? '',
                $price->repair_category_3 ?? '',
            ];
        }

        return $data;
    }

    public static function import($item)
    {
        $branch = BranchService::getByCode($item->code_subdivision);
        if (empty($branch)) {
            return ['result' => 'Branch: ' . $item->code_subdivision . ' does not exist'];
        }

        $service = Service::updateOrCreate(['inn' => $item->INN],
            [
                'name' => $item->name,
                'inn' => $item->INN,
                'additional_info' => $item->FullName,
                'branch_id' => $branch->id,
                'display' => 1,
                'external_id' => $item->code,
            ]
        );

        $createUser = [
            'service_id' => $service->id,
            'name' => $item->name,
            'email' => $item->email ?? '',
            'phone' => $item->phone ?? '',
        ];

        if (empty($service->user_id)) {
            $userService = new UserService();
            $user = $userService->userCreate($createUser);
            $user->refresh();

            $service->user_id = $user->id;
            User::withoutEvents(function () use ($service) {
                $service->save();

                return $service;
            });
        }

        $hasAddress = AddressRepository::getByServiceId($service->id)->get()->pluck('full_address')->toArray();
        if (empty($hasAddress)) {
            AddressService::saveFirstAddress([
                'name' => $item->name,
                'country' => $item->country ?? '',
                'city' => $item->city ?? '',
                'physical_address' => $item->adres,
            ], $service->id, $service->user);
        }

        return ['id' => $service->id];
    }

    public function save($fields, $managers, $createUser = null)
    {
        $serviceModel = self::getRepository()->save($fields, $managers, $createUser);

        AddressService::saveFirstAddress($fields, $serviceModel->id, $serviceModel->user);

        return $serviceModel;
    }

    /**
     * @param UpdateServiceRequest $request
     *
     * @deprecated
     * @TODO Дописать
     */
    public function update(UpdateServiceRequest $request)
    {

    }

    public static function isActiveService($serviceId, $model = null)
    {
        if (!$model) {
            $model = self::getById((int) $serviceId);
        }

        if (!$model) {
            return false;
        }

        return (bool) $model->display;
    }

    public static function updateDisplay($model)
    {
        $model->refresh();
        if ($model->display) {
            Service::where('id', '<>', $model->id)
                ->where('user_id', $model->user_id)
                ->where('display', 1)
                ->update(['display' => 0]);
        }
    }

    public static function fillStorage(array $data)
    {
        ServiceRepository::fillStorage($data);
    }

    public static function fillLeftovers($data)
    {
        ServiceRepository::fillLeftovers($data);
    }

    public static function getByCode($code)
    {
        return self::getRepository()::getByCode($code);
    }

}