<?php

namespace App\Repository\Service;

use App\Http\Requests\Service\IndexServiceRequest;
use App\Models\BalanceTransaction;
use App\Models\PartsStorage;
use App\Models\Service\Service;
use App\Repository\BaseRepository;
use App\Repository\User\UserRepository;
use App\Services\Log\LogService;
use App\Services\Service\ServiceService;
use App\Services\User\UserService;
use App\Traits\GridTrait;
use App\User;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Support\Facades\DB;

class ServiceRepository extends BaseRepository
{

    use GridTrait;

    public static function getQuery(): Builder
    {
        return Service::query();
    }

    /**
     * @param IndexServiceRequest $request
     *
     * @return mixed
     */
    public function search(IndexServiceRequest $request)
    {
        $query = self::getAvailable();

        $this->makeQueryOrdered(Service::class, $query, $request);

        $query->with(['user', 'branch']);

        if (isset($request->sortable) && $request->sortable == true && Service::sortable($request->field)) {
            $sort = $request->sort == 'asc' ? 'asc' : 'desc';

            if ($request->field == 'contact') {
                $query->whereHas('user', function ($q) use ($sort) {
                    $q->orderBy('name', $sort);
                });
            }

            if ($request->field == 'phone') {
                $query->whereHas('user', function ($q) use ($sort) {
                    $q->orderBy(\request()->field, $sort);
                });
            }

            if ($request->field == 'branch_id') {
                $query->whereHas('branch', function ($q) use ($sort) {
                    $q->orderBy('name', $sort);
                });
            }
        }

        if (isset($request->manager_id) && !empty($request->manager_id)) {
            $query->forManagerId((int) $request->manager_id);
        }

        if (isset($request->name) && !empty($request->name)) {
            $query->where('name', 'like', '%' . $request->name . '%');
        }
        if (isset($request->email) && !empty($request->email)) {
            $query->whereHas('user', function ($q) use ($request) {
                $q->where('email', 'like', '%' . $request->email . '%');
            });
        }
        if (isset($request->branch_id)) {
            $query->where('branch_id', (int) $request->branch_id);
        }

        $perPage = $request->per_page ?? config('crud.defaultPerPage');
        $data = $query->paginate((int) $perPage)->appends($request->all());

        return $data;
    }

    /**
     * @param $id
     */
    public function delete($id)
    {
        $service = self::getById($id);

        if (!empty($service->user_id)) {
            $userRepository = new UserRepository();
            $user = $userRepository::getById($service->user_id);
            if ($user) {
                $service->user()->delete();
            }
        }

        if ($service) {
            $service->delete();
        }
    }

    /**
     * Return items available for me, and available to login
     *
     * @param integer|array $branchId
     *
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public static function getByBranch($branchIds = [], $type = null)
    {
        $query = ($type && $type == 'avail') ? self::getAvailable() : self::getDisplayed();

        if (is_array($branchIds)) {
            $query->whereIn('branch_id', $branchIds);
        } else {
            $branchIds = (int) $branchIds;
            $query->where('branch_id', $branchIds);
        }

        return $query;
    }

    /**
     * @param $id
     */
    public static function save($fields, $managers = [], $createUser = null)
    {
        $serviceModel = new Service();
        $serviceModel->fill($fields);
        $serviceModel->user_id = $fields['user_id'] ?? 0;
        $serviceModel->save();

        $serviceModel->refresh();
        if (!empty($managers)) {
            $serviceModel->managers()->sync($managers);
            LogService::updatedRelations($serviceModel, 'managers', $managers);
        }

        //
        if ($createUser) {
            $createUser['service_id'] = $serviceModel->id;

            $userService = new UserService();
            $user = $userService->userCreate($createUser);
            $user->refresh();

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

                return $serviceModel;
            });

        } else {
            if ($serviceModel->user_id) {
                //
                $user = User::where('id', $serviceModel->user_id)->first();
                if (!$user->isMultiService()) {
                    $services = ServiceService::getAvailable()
                        ->where('user_id', $user->id)
                        ->orderBy('id', 'desc')->count();

                    if ($services > 1) {
                        $user->multiservice = 1;

                        User::withoutEvents(function () use ($user) {
                            $user->save();

                            return $user;
                        });
                    }
                }
            }
        }

        return $serviceModel;
    }

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

    }

    public static function fillStorage(array $data)
    {
        $sql = 'INSERT INTO repair_prices (device_external_id, service_id, repair_category_1, repair_category_2, repair_category_3)';
        $sql .= 'VALUES(' . join(', ', [$data['sku'], $data['serviceId'], $data['category1'], $data['category2'], $data['category3']]) . ')';
        $sql .= 'ON DUPLICATE KEY UPDATE repair_category_1 = ' . $data['category1'] . ', repair_category_2 = ' . $data['category2'] . ', repair_category_3 = ' . $data['category3'] . ';';
        DB::statement($sql);
    }

    public static function fillLeftovers($data)
    {
        $service = PartsStorage::service;
        DB::statement(
            "INSERT INTO parts_storage
            (`part_id`, `warehouse_id`, `amount`, `type`, `external_warehouse_id`)
            values($data[4], $data[3], $data[1],'$service', '$data[2]')
            ON DUPLICATE KEY UPDATE `amount` = $data[1]"
        );
    }

    public static function getByCode($code)
    {
        return Service::where('external_id', $code)->first();
    }

    public static function getStartBalance(int $serviceId): float
    {
        return BalanceTransaction::query()->where('service_id', $serviceId)->sum('amount');
    }

    public static function setBalance(int $serviceId, float $newBalance, ?int $userId = null): void
    {
        $unitBalance = self::getStartBalance($serviceId);
        if ($newBalance == $unitBalance) {
            return;
        }

        if (empty($userId)) {
            /** @var User $user */
            $user = Auth()->user();
            $userId = $user->id;
        }

        $newTransaction = new BalanceTransaction(['service_id' => $serviceId, 'user_id' => $userId]);
        $newTransaction->amount = $newBalance - $unitBalance;
        $newTransaction->save();
    }

}