<?php

namespace App\Http\Controllers;

use App\Helpers\UserHelper;
use App\Http\Requests\AjaxSelectRequest;
use App\Http\Requests\IdRequest;
use App\Http\Requests\ImportRequest;
use App\Http\Requests\Service\CreateServiceRequest;
use App\Http\Requests\Service\IndexServiceRequest;
use App\Http\Requests\Service\SavePriceRequest;
use App\Http\Requests\Service\UpdateServiceRequest;
use App\Http\Requests\UploadRequest;
use App\Http\Requests\User\CreateRequest;
use App\Models\Branch;
use App\Models\Part;
use App\Models\Permission;
use App\Models\Repair\Repair;
use App\Models\Role;
use App\Models\Service\Service;
use App\Repository\Service\ServiceRepository;
use App\Services\Branch\BranchService;
use App\Services\Log\LogService;
use App\Services\Service\ServiceService;
use App\Services\User\RoleService;
use App\Services\User\UserService;
use App\Traits\RoleTrait;
use App\Traits\UserTrait;
use App\User;
use Exception;
use Illuminate\Support\Facades\Validator;
use PhpOffice\PhpSpreadsheet\IOFactory;

class ServiceController extends Controller
{

    use UserTrait, RoleTrait;

    /** @var string */
    protected string $permission = Permission::services;

    /** @var ServiceService */
    protected ServiceService $service;

    /**
     * ServiceController constructor.
     */
    public function __construct()
    {
        parent::__construct();

        $this->service = new ServiceService();
    }

    public function index(IndexServiceRequest $request)
    {
        $request->validate($request->rules());

        $data = $this->service->search($request);

        $branches = BranchService::getDisplayed();
        $managers = UserService::getManagers();

        $columns = Service::columns();

        return view('services.list', compact('data', 'columns', 'managers', 'branches'))->with(['sections' => ['branch_id', 'manager_id']]);
    }

    public function fillLeftoversBtn()
    {
        $services = ServiceRepository::all();
        foreach ($services as $service) {
            $repair = Repair::where('service_id', $service->id)->where('status', 'completed')->first();
            if ($repair) {
                Service::withoutEvents(function () use ($service) {
                    $service->leftovers_btn = 0;
                    $service->save();

                    return $service;
                });
            }
        }
    }

    public function create()
    {
        $model = new Service();
        $modelUser = new User();
        $validate = new CreateServiceRequest();
        $validateUser = new CreateRequest();

        $user = UserHelper::getUser();

        $modelUser->role = old('role') ?? Role::where('type', Role::service)->first()->id;
        $model->branch_id = old('branch_id') ?? $user->getFirstBranchId();

        $branches = BranchService::getDisplayed();
        $roles = RoleService::getServiceRoles();

        $managers = ($model->branch_id) ? UserService::getManagers($model->branch_id) : [];
        $selectedManager = ($user->isManager()) ? $user->getAuthIdentifier() : 0;

        return view('services.create', compact('model', 'modelUser', 'managers', 'branches', 'validate', 'validateUser', 'roles', 'selectedManager'))
            ->with(['sections' => ['branch_id', 'managers', 'role']]);
    }

    public function store(CreateServiceRequest $request)
    {
        $request->validate($request->rules());
        $fields = $request->all();

        $this->serviceCreate($fields);

        return redirect()->route('services.index')->with('messageSuccess', __('services.messageCreateServices'));
    }

    protected function serviceCreate($fields)
    {
        $managers = $fields['managers'] ?? [];
        unset($fields['managers']);

        $availableManagers = UserService::getManagers();
        $availableManagers = array_keys($availableManagers);

        $setManagers = array_intersect($managers, $availableManagers);

        $fieldsUser = [];
        foreach ($fields as $name => $value) {
            if (strpos($name, 'user_') === 0) {
                $name = str_replace('user_', '', $name);
                $fieldsUser[$name] = $value;
            }
        }
        $fieldsUser['role'] = $fields['role'];
        unset($fields['role']);
        $fieldsUser['access_system'] = $fields['display'] ?? 0;
        $fieldsUser['branch_id'] = $fields['branch_id'] ?? 0;
        if (!can(Permission::branchesAll)) {
            $user = UserHelper::getUser();
            $fieldsUser['branch_id'] = $user->getFirstBranchId();
            $fields['branch_id'] = $user->getFirstBranchId();
        }

        $serviceModel = $this->service->save($fields, $setManagers, $fieldsUser);

        //$fieldsUser['service_id'] = $serviceModel->id;
        //$this->userCreate($fieldsUser);
    }

    public function show(IdRequest $request)
    {
        $service = ServiceService::getById($request->id);

        $allServices = null;
        if ($service->user->isMultiService()) {
            $allServices = $service->user->getAllServices();
        }

        return view('services.show', compact('service', 'allServices'));
    }

    public function edit(IdRequest $request)
    {
        $data = ServiceService::getById($request->id);

        $formBranchId = old('branch_id') ?? $data->branch->id;

        $validate = new UpdateServiceRequest();

        $branches = BranchService::getDisplayed();
        if (can(Permission::branchesAll)) {

            if ($data->branch && $data->branch->display == 0) {
                $branches[$data->branch->id] = $data->branch->name;
            }
        }

        $managersRelation = $data->managers()->get()->pluck('name', 'id')->toArray();
        $managers = UserService::getManagers($formBranchId);

        if ($managersRelation) {
            $managers += $managersRelation;
        }
        $managersRelation = array_keys($managersRelation);

        return view('services.edit', compact('data', 'managersRelation', 'managers', 'validate', 'branches'))->with(['sections' => ['managers', 'branch_id']]);
    }

    public function update(UpdateServiceRequest $request)
    {
        $request->validate($request->rules());

        $fields = $request->all();
        if (!isset($fields['display'])) {
            $fields['display'] = 0;
        }

        $managers = $fields['managers'] ?? [];
        unset($fields['managers']);

        if (!can(Permission::external) && isset($fields['external_id'])) {
            unset($fields['external_id']);
        }

        if (isset($fields['balance'])) {
            $balance = (double) $fields['balance'];
            unset($fields['balance']);
        }

        $availableManagers = UserService::getManagers();
        $availableManagers = array_keys($availableManagers);

        $setManagers = array_intersect($managers, $availableManagers);

        /** @var Service $service */
        $service = ServiceService::getById($request->id);

        $service->fill($fields);

        $service->update();

        if (isset($balance)) {
            ServiceRepository::setBalance($service->id, $balance);
        }

        $service->managers()->sync($setManagers);
        LogService::updatedRelations($service, 'managers', $setManagers);

        return redirect()->route('services.index')->with('messageSuccess', __('services.messageUpdateServices'));
    }

    /**
     * Remove the specified resource from storage.
     *
     * @param int $id
     *
     * @return \Illuminate\Http\RedirectResponse
     */
    public function delete($id)
    {
        $this->service->delete($id);

        return redirect()->route('services.index')
            ->with('messageSuccess', __('services.messageDeleteServices'));
    }

    public function importView()
    {
        if (!can(Permission::servicesImport)) {
            return redirect()->route('services.index');
        }

        return view('services.import');
    }

    public function uploadFile(UploadRequest $request)
    {
        if (!can(Permission::servicesImport)) {
            redirect()->route('services.index');
        }

        $file = $request->file('file')->store('app/public/import');

        return response()->json(['success' => $file]);
    }

    public function getDataFromXls($file)
    {
        $reader = IOFactory::createReaderForFile($file);
        $reader->setReadDataOnly(true);
        $spreadsheet = $reader->load($file);

        $worksheet = $spreadsheet->getActiveSheet();

        $res = [];
        foreach ($worksheet->getRowIterator() as $row) {
            $cellIterator = $row->getCellIterator();
            $cellIterator->setIterateOnlyExistingCells(FALSE);

            $data = [];
            foreach ($cellIterator as $cell) {
                array_push($data, $cell->getValue());
            }
            array_push($res, $data);
        }

        return $res;
    }

    public function getBranchId($service_name, $branches)
    {
        foreach ($branches as $branch) {
            if (trim($branch[8]) == trim($service_name)) {
                $external_id = strtok(trim($branch[1]), '0');
                $b = Branch::where('external_id', $external_id)->first();
                if ($b) {
                    return $b->id;
                } else {
                    $b = new Branch();
                    $b->name = $branch[3];
                    $b->external_id = $external_id;
                    $b->save();

                    return $b->id;
                }
            }
        }
    }

    public function saveDataFromImport($services, $branches)
    {
        $countSuccess = 0;
        $countError = 0;
        $inlineErrors = [];

        $fieldsService = [
            6 => 'country',
            'physical_address',
            'legal_address',
            'additional_info',
            'bank_name',
            'bank_bik',
            'bank_inn',
            'bank_score',
            'bank_cor_score',
        ];
        $fieldsUser = [
            1 => 'name',
            'email',
            'additional_email',
            'phone',
            'additional_phone',
        ];

        $row = 0;

        foreach ($services as $data) {
            $row++;

            if ($row === 1) {
                continue;
            }
            $serviceData = [
                'display' => 1,
                'name' => $data[0],
                'inn' => (string) $data[12],
            ];
            foreach ($fieldsService as $key => $field) {
                $serviceData[$field] = trim($data[$key]);
            }

            $userData = [
                'access_system' => 1,
                'lang' => config('app.locale'),
            ];
            foreach ($fieldsUser as $key => $field) {
                $userData[$field] = trim($data[$key]);
            }

            $commonData = $serviceData;
            foreach ($userData as $field => $value) {
                $commonData['user_' . $field] = $value;
            }

            $role = $this->getRoleIdSlug(Role::service);
            $commonData['role'] = $role;
            $commonData['branch_id'] = $this->getBranchId($data[0], $branches);
            $commonData['country'] = $data[6];
            $commonData['city'] = '';
            $commonData['physical_address'] = $data[7];
            $commonData['main'] = 1;

            $request = new CreateServiceRequest();
            $validatorService = Validator::make($commonData, $request->rules());
            if ($validatorService->fails()) {
                $messages = $validatorService->errors()->getMessages();
                $concatMessages = '';
                foreach ($messages as $message) {
                    if (!empty($concatMessages)) {
                        $concatMessages .= '; ';
                    }
                    $concatMessages .= implode(', ', $message);
                }

                $inlineErrors[] = __('services.serviceErrorList', ['name' => $commonData['name'], 'errors' => $concatMessages]);
                $countError++;
                continue;
            }
            $this->serviceCreate($commonData);
            $countSuccess++;
        }

        $result = [];
        if (count($inlineErrors)) {
            $result = ['inlineErrors' => $inlineErrors];
        }

        if ($countError) {
            $result['messageError'] = __('services.badServices', ['x' => $countError]);
        }
        if ($countSuccess) {
            $result['messageSuccess'] = __('services.goodServices', ['x' => $countSuccess]);
        }

        return $result;
    }

    public function import(ImportRequest $request)
    {
        if (!can(Permission::servicesImport)) {
            redirect()->route('services.index');
        }

        try {
            $file1 = storage_path() . '/' . $request->filePath[0];
            $file2 = storage_path() . '/' . $request->filePath[1];
        } catch (\Exception $e) {
            return redirect()->route('services.index')->with("messageError", __('services.wrongFile'));
        }

        if (!file_exists($file1) || !file_exists($file2)) {
            return redirect()->route('services.import');
        }

        try {
            $data1 = $this->getDataFromXls($file1);
            $data2 = $this->getDataFromXls($file2);

            if (count($data1[0]) == '15' && count($data2[0]) == '9') {
                $result = $this->saveDataFromImport($data1, $data2);

                return redirect()->route('services.index')->with($result);
            } elseif (count($data1[0]) == '9' && count($data2[0]) == '15') {
                $result = $this->saveDataFromImport($data2, $data1);

                return redirect()->route('services.index')->with($result);
            } else {
                return redirect()->route('services.index')->with("messageError", __('services.wrongFile'));
            }
        } catch (\Exception $e) {
            return redirect()->route('services.index')->with("messageError", __('services.wrongFile'));
        }
    }

    public function managers(AjaxSelectRequest $request)
    {
        $items = UserService::getManagersAjax($request->id, $request->search);

        return response()->json(compact('items'));
    }

    public function formPrice(IdRequest $request)
    {
        if (!$request->id) {
            return redirect()->route('services.index');
        }

        $service = ServiceService::getById($request->id);

        return view('services.price', compact('service'));
    }

    public function checkDelimiter($handle)
    {
        $delimiter = ';';
        $test = fgetcsv($handle, 0, $delimiter);
        $num = count($test);
        if ($num < 2) {
            rewind($handle);
            $delimiter = ',';
            $test = fgetcsv($handle, 0, $delimiter);
            $num = count($test);
            if ($num < 2) {
                rewind($handle);

                return false;
            }
        }

        rewind($handle);

        return $delimiter;
    }

    public function downloadPrice(IdRequest $request)
    {
        $data = ServiceService::getPrices($request->id);

        $fileName = 'prices.csv';

        $headers = [
            'Content-Encoding' => 'UTF-8',
            'Content-type' => 'text/csv; charset=utf-8',
            'Content-Disposition' => 'attachment; filename=' . $fileName,
            'Pragma' => 'no-cache',
            'Cache-Control' => 'must-revalidate, post-check=0, pre-check=0',
            'Expires' => '0',
        ];

        $fp = fopen('php://output', 'w+');
        fputs($fp, "\xEF\xBB\xBF");
        $callback = function () use ($data, $fp) {
            foreach ($data as $row) {
                fputcsv($fp, $row, ';');
            }
            fclose($fp);
        };

        return response()->streamDownload($callback, $fileName, $headers);
    }

    public function savePrice(SavePriceRequest $request)
    {
        $file = storage_path() . '/' . $request->filePath[0];

        if (!file_exists($file)) {
            return redirect()->route('services.price.form', $request->id)->with('messageError', __('services.wrongFile'));
        }

        /** @var Service $service */
        $service = ServiceService::getById($request->id);

        try {
            $reader = IOFactory::createReaderForFile($file);
            $reader->setReadDataOnly(true);
            $spreadsheet = $reader->load($file);

            $worksheet = $spreadsheet->getActiveSheet();

            foreach ($worksheet->getRowIterator() as $row) {
                $cellIterator = $row->getCellIterator();
                $cellIterator->setIterateOnlyExistingCells(FALSE);

                $data = [];
                foreach ($cellIterator as $cell) {
                    $data[] = $cell->getValue();
                }

                $rowData = [
                    'sku' => $data[0],
                    'category1' => $data[2],
                    'category2' => $data[3],
                    'category3' => $data[4],
                    'serviceId' => $service->id,
                ];

                if (is_numeric($rowData['category1']) && is_numeric($rowData['category2']) && is_numeric($rowData['category3'])) {
                    ServiceService::fillStorage($rowData);
                }
            }

            return redirect()->route('services.index')->with('messageSuccess', __('services.successfulImport'));
        } catch (Exception $e) {
            return redirect()->route('services.index')->with('messageError', __('services.wrongFile'));
        }
    }

    public function formLeftovers(IdRequest $request)
    {
        if (session()->has('warehouseNotFound')) {
            session()->forget('warehouseNotFound');
        }

        if (!$request->id) {
            return redirect()->route('services.index');
        }

        $service = ServiceService::getById($request->id);
        if (!$service->external_warehouse_id) {
            session()->put('warehouseNotFound', 1);
        }

        return view('services.leftovers', compact('service'));
    }

    public function saveLeftovers(SavePriceRequest $request)
    {
        $service = ServiceService::getById($request->id);
        if (!$service->external_warehouse_id) {
            return redirect()->route('services.edit', $service->id)
                ->with("messageError", __('services.warehouseError'));
        }

        $file = storage_path() . '/' . $request->filePath[0];

        if (!file_exists($file)) {
            return redirect()->route('services.leftovers.form', $request->id)
                ->with("messageError", __('services.wrongFile'));
        }

        try {
            $reader = IOFactory::createReaderForFile($file);
            $reader->setReadDataOnly(true);
            $spreadsheet = $reader->load($file);

            $worksheet = $spreadsheet->getActiveSheet();

            $not_found = [];
            $success = 0;
            foreach ($worksheet->getRowIterator() as $row) {
                $cellIterator = $row->getCellIterator();
                $cellIterator->setIterateOnlyExistingCells(FALSE);

                $data = [];
                foreach ($cellIterator as $cell) {
                    array_push($data, $cell->getValue());
                }
                if ($data[0] && is_numeric($data[1]) && $data[1] > 0) {
                    $part = Part::where('external_id', $data[0])->first();
                    if ($part) {
                        array_push($data, $service->external_warehouse_id);
                        array_push($data, 0);
                        array_push($data, $part->id);
                        ServiceService::fillLeftovers($data);
                        $success++;
                    } else {
                        array_push($not_found, $data[0]);
                    }
                }
                if (!empty($not_found)) {
                    session()->put('notFound', $not_found);
                }
            }

            if ($success && !session()->get('notFound')) {
                return redirect()->route('services.leftovers.form', $request->id)
                    ->with("messageSuccess", __('services.successfulLeftoversImport', ['X' => $success]));
            } elseif ($success && session()->get('notFound')) {
                return redirect()->route('services.leftovers.form', $request->id)
                    ->with("messageSuccess", __('services.successfulLeftoversImport', ['X' => $success]))
                    ->with("messageError", __('services.unsuccessfulLeftoversImport', ['X' => count($not_found)]));
            } else {
                return redirect()->route('services.leftovers.form', $request->id)
                    ->with("messageError", __('services.unsuccessfulLeftoversImport', ['X' => count($not_found)]));
            }
        } catch (\Exception $e) {
            return redirect()->route('services.leftovers.form', $request->id)
                ->with("messageError", __('services.wrongFile'));
        }
    }
}