<?php

namespace App\Http\Controllers;

use App\Http\Requests\EmployeeAddressUpdateRequest;
use App\Http\Requests\EmployeeBankUpdateRequest;
use App\Http\Requests\EmployeeFamilyUpdateRequest;
use App\Http\Requests\EmployeeForgottenPasswordRequest;
use App\Http\Requests\EmployeeFormationQuestionRequest;
use App\Http\Requests\EmployeeLoginRequest;
use App\Http\Requests\EmployeeMailChangeRequest;
use App\Http\Requests\EmployeePasswordChangeRequest;
use App\Http\Requests\EmployeeRdvQuestionRequest;
use App\Http\Requests\EmployeeResetPasswordRequest;
use App\Http\Requests\ImportEmployeesCsvFile;
use App\Imports\EmployeeImport;
use App\Imports\EmployeeSortie;
use App\Jobs\SendEmployeeInfoMailToSiteRH;
use App\Jobs\SendEmployeeLockedDownMailToEmployee;
use App\Jobs\SendEmployeeLockedDownMailToSiteRH;
use App\Jobs\SendMailConfirmToEmployee;
use App\Jobs\SendMailResetPasswordToEmployee;
use App\Mail\EmployeeInfoAddress;
use App\Mail\EmployeeInfoBank;
use App\Mail\EmployeeInfoFamily;
use App\Mail\EmployeeLockedDown;
use App\Mail\EmployeeQuestionFormation;
use App\Mail\EmployeeQuestionRdv;
use App\Mail\EmployeeYourAccountIsLockedDown;
use App\Models\Employee;
use App\Models\EmployeeMailToken;
use App\Models\Site;
use Exception;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Foundation\Http\FormRequest;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Session;
use Illuminate\Support\Facades\View;
use Kwaadpepper\CrudPolicies\Traits\CrudController;
use Maatwebsite\Excel\Excel as LExcel;
use Maatwebsite\Excel\Facades\Excel;
use PhpOffice\PhpSpreadsheet\Reader\Exception as ReaderException;

class EmployeesController extends Controller
{
    use CrudController;

    /** @var Employee */
    public static $modelClass = Employee::class;

    // BO

    // Eloquent callbacks
    public function indexQuery(Builder $query): Builder
    {
        /** @var \App\Models\User */
        $user = auth()->user();
        return $query->where('site_id', $user->selected_site_id);
    }

    public function storeModel(Model &$model)
    {
        /** @var \App\Models\User */
        $user = auth()->user();
        $model->site_id = $user->selected_site_id;
    }

    public function storedModel(Model &$model)
    {
        /** @var \App\Models\Employee */
        $model = $model;
        $model->sendMailConfirm();
    }

    public function updateModel(Model &$model)
    {
        /** @var \App\Models\User */
        $user = auth()->user();
        $model->site_id = $user->selected_site_id;
    }

    public function importExit()
    {
        $this->authorize('importExit', Employee::class);
        View::share('modelsClasses', static::getCrudModels());
        return view('back.employees.import-exit');
    }

    public function importExitSubmit(ImportEmployeesCsvFile $request)
    {
        $this->authorize('import', Employee::class);
        /** @var \App\Models\User */
        $user = auth()->user();
        /** @var \App\Models\Site */
        $site = Site::where('id', $user->selected_site_id)->firstOrFail();
        $employeeImport = null;
        try {
            $employeeImport = new EmployeeSortie($site);
            Excel::import(
                $employeeImport,
                $request->file,
                null,
                LExcel::CSV
            );
        } catch (ReaderException $e) {
            // this time cannot read anything
            return redirect()->back()->withErrors(
                // phpcs:ignore Generic.Files.LineLength.TooLong
                'Echec lors de l\'import le fichier doit être conforme à celui fourni lors du developement de l\'application'
            );
        } catch (Exception $e) {
            // $employeeImport->errorMessages
            // this time cannot read anything
            return redirect()->back()->withErrors(sprintf(
                'Echec lors de l\'import %s',
                $e->getMessage()
            ));
        } finally {
            $message = sprintf(
                "%d salariés ont été supprimés",
                $employeeImport->removedCount,
            );
            if (count($employeeImport->importedFailed)) {
                $message .= sprintf(
                    "\n %d echecs\n Les lignes suivantes ont été ignorés \n%s\n",
                    count($employeeImport->importedFailed),
                    \collect($employeeImport->importedFailed)->map(function ($d) {
                        return $d->implode(',');
                    })->implode("\n"),
                );
            }
            if (count($employeeImport->errorMessages)) {
                $message .= sprintf(
                    "\n %d erreurs\n Les erreurs suivantes sont apparues %s",
                    count($employeeImport->errorMessages),
                    implode("\n", $employeeImport->errorMessages),
                );
            }
            return redirect()->route('bo.employees.importExit')
            ->with('success', $message);
        }
    }

    public function import()
    {
        $this->authorize('import', Employee::class);
        View::share('modelsClasses', CrudController::getCrudModels());
        return view('back.employees.import');
    }

    public function importSubmit(ImportEmployeesCsvFile $request)
    {
        $this->authorize('import', Employee::class);
        /** @var \App\Models\User */
        $user = auth()->user();
        /** @var \App\Models\Site */
        $site = Site::where('id', $user->selected_site_id)->firstOrFail();
        $employeeImport = null;
        try {
            $employeeImport = new EmployeeImport($site);
            Excel::import(
                $employeeImport,
                $request->file,
                null,
                LExcel::CSV
            );
        } catch (Exception $e) {
            // this time cannot read anything
            return redirect()->back()->withErrors(sprintf(
                'Echec lors de l\'import %s',
                $e->getMessage()
            ));
        } catch (ReaderException $e) {
            // this time cannot read anything
            return redirect()->back()->withErrors(
                // phpcs:ignore Generic.Files.LineLength.TooLong
                'Echec lors de l\'import le fichier doit être conforme à celui fourni lors du developement de l\'application'
            );
        } finally {
            $message = '';
            $errors = [];
            foreach ($employeeImport->errorMessages as $k => $err) {
                $errors[] = sprintf(
                    "\nLigne %d :\n%s\nDonnée:\n%s\n",
                    $k + 1,
                    \implode("\n", $err),
                    \implode(", ", $employeeImport->importedFailed[$k]->all())
                );
            }
            if (count($errors)) {
                $message = sprintf(
                    // phpcs:ignore Generic.Files.LineLength.TooLong
                    "%d salariés ont été importés \n %d salariés mis à jour\n %d erreurs\n Les erreurs suivantes sont apparues %s",
                    $employeeImport->importedCount,
                    $employeeImport->updatedCount,
                    count($errors),
                    implode("\n", $errors),
                );
            } else {
                $message = sprintf(
                    "%d salariés ont été importés",
                    $employeeImport->importedCount,
                );
            }
            return redirect()->route('bo.employees.import')
            ->with('success', $message);
        }
    }

    // FO

    public function logout()
    {
        /** @var \Illuminate\Auth\SessionGuard */
        $guard = Auth::guard('employee');
        $guard->logout();
        return redirect()->route('employees.login');
    }

    public function loginSubmit(EmployeeLoginRequest $request)
    {
        /** @var \Illuminate\Auth\SessionGuard */
        $guard = Auth::guard('employee');

        if (!($employee = Employee::where('matricule', $request->login)->first())) {
            return \redirect()->route('employees.login')
                ->withErrors(['Les identifiants fournis sont incorrects'], 'login');
        }

        // Is employee locked down ?
        if ($employee->password_attempts >= 3) {
            return \redirect()->route('employees.login')
            ->withErrors([trans(sprintf(
                'Votre compte est verrouillé, veuillez contacter votre responsable RH pour le déverrouiller',
                3 - $employee->password_attempts
            ))], 'lockedDown')->with('site', $employee->site);
        }

        // phpcs:ignore Generic.Files.LineLength.TooLong
        if (!$guard->attempt(['matricule' => $request->login, 'password' => $request->password], $request->rememberMe)) {
            $employee->password_attempts = $employee->password_attempts + 1;
            $employee->saveOrFail();

            // Is employee locked down ?
            if ($employee->password_attempts >= 3) {
                SendEmployeeLockedDownMailToEmployee::dispatch(
                    new EmployeeLockedDown($employee),
                    $employee
                );
                SendEmployeeLockedDownMailToSiteRH::dispatch(
                    new EmployeeYourAccountIsLockedDown($employee),
                    $employee
                );
                return \redirect()->route('employees.login')
                ->withErrors(
                    // phpcs:ignore Generic.Files.LineLength.TooLong
                    [trans('Votre compte est verrouillé, veuillez contacter votre responsable RH pour le déverrouiller')],
                    'lockedDown'
                )->with('site', $employee->site);
            }

            return \redirect()->route('employees.login')
            ->withErrors([trans(sprintf(
                // phpcs:ignore Generic.Files.LineLength.TooLong
                'Attention plus que %d essais, après cela votre compte sera verrouillé et un mail sera envoyé à votre responsable RH (seul lui peut déverrouiller votre compte)',
                3 - $employee->password_attempts
            ))], 'login');
        }

        // reset password attempts if successful login
        $employee->password_attempts = 0;
        $employee->saveOrFail();

        $request->session()->regenerate();
        return redirect()->intended(route('fo.access'));
    }

    public function passwordForgottenSubmit(EmployeeForgottenPasswordRequest $request)
    {
        /** @var \App\Models\Employee */
        $employee = Employee::where('matricule', $request->matricule)->firstOrFail();
        /** @var \App\Models\EmployeeMailToken */
        $token = EmployeeMailToken::whereHas('employee', function ($q) use ($employee) {
            $q->where('id', $employee->id);
        })->firstOrNew();
        $token->email = $employee->email;
        $token->employee()->associate($employee);
        $token->saveOrFail();
        SendMailResetPasswordToEmployee::dispatchAfterResponse($employee, $token);
        return \redirect()->back()->with('successMail', true);
    }

    public function resetPassword(EmployeeMailToken $token = null)
    {
        if ($token) {
            Session::put('resetMail', time());
            Session::put('resetMailEmployee', $token->employee);
            Session::save();
            $token->delete();
        }

        // If token has been consumed and we has a resetMail in Session then pass trough
        if (Session::has('resetMail') and (Session::get('resetMail') + 60 * 4) > time()) {
            return view('front.employees.changePassword', ['reset' => true]);
        }
        Session::forget('resetMail');
        Session::forget('resetMailEmployee');
        Session::save();
        return redirect()->route('fo.access');
    }

    public function resetPasswordSubmit(EmployeeResetPasswordRequest $request)
    {
        /** @var Employee */
        if ($employee = Session::get('resetMailEmployee', null)) {
            $employee->password = $request->newpassword;
            $employee->saveOrFail();
            Session::forget('resetMail');
            Session::forget('resetMailEmployee');
            Session::save();
            return redirect()->route('employees.done-reset-password');
        }
        return redirect()->route('fo.access');
    }

    public function passwordChangeSubmit(EmployeePasswordChangeRequest $request)
    {
        /** @var \app\Models\Employee */
        $employee = auth('employee')->user();
        $employee->password = $request->newpassword;
        $employee->saveOrFail();
        if (Session::has('required')) {
            Session::remove('required');
            Session::save();
            return redirect()->route('fo.access')
                ->with('message', trans('Votre mot de passe a bien été mis à jour'));
        }
        return \redirect()->back()->with('success', true);
    }

    public function mailUpdate(EmployeeMailChangeRequest $request)
    {
        /** @var \app\Models\Employee */
        $employee = auth('employee')->user();
        $token = $employee->token ?? new EmployeeMailToken();
        $token->fill([
            'email' => $request->email,
            'employee_id' => $employee->id
        ]);
        $token->saveOrFail();
        $token->employee()->associate($token);
        SendMailConfirmToEmployee::dispatchAfterResponse($employee);
        return \redirect()->back()->with('successMail', true)
        ->with('message', trans('Informations mises à jour'));
    }

    public function confirmMail(EmployeeMailToken $token)
    {
        $employee = $token->employee;
        $employee->email = $token->email;
        $employee->saveOrFail();
        $token->delete();
        return view('front.emailActivated');
    }

    public function familyUpdate(EmployeeFamilyUpdateRequest $request)
    {
        $this->sendInfo(EmployeeInfoFamily::class, $request);
        return \redirect()->back()->with('success', true)
        ->with('message', trans('Informations transmises'));
    }

    public function addressUpdate(EmployeeAddressUpdateRequest $request)
    {
        $this->sendInfo(EmployeeInfoAddress::class, $request);
        return \redirect()->back()->with('success', true)
        ->with('message', trans('Informations transmises'));
    }

    public function bankUpdate(EmployeeBankUpdateRequest $request)
    {
        $this->sendInfo(EmployeeInfoBank::class, $request);
        return \redirect()->back()->with('success', true)
        ->with('message', trans('Informations transmises'));
    }

    public function questionFormation(EmployeeFormationQuestionRequest $request)
    {
        $this->sendInfo(EmployeeQuestionFormation::class, $request);
        return \redirect()->back()->with('success', true)
        ->with('message', trans('Informations transmises'));
    }

    public function questionRdv(EmployeeRdvQuestionRequest $request)
    {
        $this->sendInfo(EmployeeQuestionRdv::class, $request);
        return \redirect()->back()->with('success', true)
        ->with('message', trans('Informations transmises'));
    }

    private function sendInfo(string $mailClass, FormRequest $request)
    {
        SendEmployeeInfoMailToSiteRH::dispatchAfterResponse(
            new $mailClass(
                array_merge(
                    ['employee' => auth('employee')->user()],
                    $request->validated()
                )
            ),
            auth('employee')->user()
        );
    }
}