<?php

namespace App\Http\Controllers\Club;

use App\Casts\NiceDate;
use App\Enums\Departaimants\DepartaimantCollectionType;
use App\Enums\Departaimants\DepartaimantStatus;
use App\Http\Controllers\Controller;
use App\Http\Requests\Club\Bourse\SaveCustomerCollectionRequest;
use App\Http\Requests\Club\Bourse\SearchCustomerCollectionRequest;
use App\Lib\Utils;
use App\Models\BlockList;
use App\Models\DepartaimantsCollection;
use Illuminate\Contracts\Database\Eloquent\Builder;
use Illuminate\Contracts\View\View;
use Illuminate\Http\JsonResponse;
use Illuminate\Support\Arr;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Auth;

class DepartaimantController extends Controller
{
    /**
     * Show index page
     *
     * @return \Illuminate\Contracts\View\View
     */
    public function index(): View
    {
        /** @var \App\Models\Customer */
        $customer       = Auth::guard('club')->user();
        $depCollections = $customer->getOrCreateAllDepartaimentsCollections();

        $departaimants = $this->getUserDepartaimantsMaps($depCollections);

        return view('club.pages.departaimants.index', compact('departaimants'));
    }

    /**
     * Save Customer collection state
     *
     * @param \App\Http\Requests\Club\Bourse\SaveCustomerCollectionRequest $request
     * @param \App\Enums\Departaimants\DepartaimantCollectionType          $collectiontype
     * @return mixed|\Illuminate\Http\JsonResponse
     * @throws \RuntimeException If a collection type is missing.
     */
    public function bourseSaveState(SaveCustomerCollectionRequest $request, DepartaimantCollectionType $collectiontype)
    {
        /** @var \App\Models\Customer */
        $customer = Auth::guard('club')->user();
        /** @var \App\Models\DepartaimantsCollection $departaimantCollection */
        $departaimantCollection = $customer->departaimantsCollections()
            ->where('type', $collectiontype->value())->firstOrFail();

        $depStatus = DepartaimantStatus::make($request->integer('state'));
        /** @var string|null */
        $depEnumClass = Arr::get($request->maps, $collectiontype->value(), null);
        if (!$depEnumClass) {
            throw new \RuntimeException("Missing " . $collectiontype->value() . 'from request');
        }
        /** @var \App\Enums\Departaimants\IDepartaimant */
        $departaimant = forward_static_call(
            [$depEnumClass, 'make'],
            $request->input('id')
        );

        $departaimantCollection->set($departaimant, $depStatus);

        $departaimantCollection->saveOrFail();

        $depCollections = $customer->getOrCreateAllDepartaimentsCollections();

        return response()->json([
            'status' => 'OK',
            'map' => $this->getUserDepartaimantsMaps($depCollections)
        ]);
    }

    /**
     * Summary of bourseSearch
     *
     * @param \App\Http\Requests\Club\Bourse\SearchCustomerCollectionRequest $request
     * @param \App\Enums\Departaimants\DepartaimantCollectionType            $collectiontype
     * @return \Illuminate\Http\JsonResponse
     */
    public function bourseSearch(SearchCustomerCollectionRequest $request, DepartaimantCollectionType $collectiontype): JsonResponse
    {
        $output       = collect();
        $state        = DepartaimantStatus::make((int)$request->input('state'));
        $pseudo       = $request->string('pseudo', '');
        $departaimant = str_replace(['-', ' ', '\''], '', strtolower($request->string('departaimant', '')));
        $departaimant = Utils::replaceSpecChar($departaimant);

        if ($state->equals(DepartaimantStatus::gives)) {
            $status = DepartaimantStatus::wants;
        } elseif ($state->equals(DepartaimantStatus::wants)) {
            $status = DepartaimantStatus::gives;
        } else {
            return response()->json([
                'status' => 'KO',
                'message' => 'Message cannot search with other status than wants or gives'
            ]);
        }

        /** @var \App\Models\Customer */
        $customer      = Auth::guard('club')->user();
        $ids           = collect(BlockList::query()->select('customer_id', 'blocked_id')
            ->whereHas('customer', fn (Builder $q) => $q->where('id', $customer->id))
            ->orWhereHas('blocked', fn (Builder $q) => $q->where('id', $customer->id))
            ->get()->toArray());
        $ids           = $ids->flatten()->unique();
        $userDep       = $customer->departaimantsCollections()->where('type', $collectiontype->value)->first();
        $userDepStatus = [];
        foreach ($userDep->getAllDepartaimants() as $dep) {
            if ($dep->status->value === $state->value) {
                // * hack to prevent php to cast array key to int
                $userDepStatus['.' . $dep->departaimant->value] = $dep->departaimant;
            }
        }

        $req = DepartaimantsCollection::getDepartaimantsCollectionWithStatus($userDepStatus, $status, $collectiontype)
            ->with('customer');

        $req->whereHas('customer', function (Builder $query) use ($pseudo, $ids) {
            // * handle blocked ids
            if ($ids->count()) {
                $query->whereNotIn('id', $ids);
            }
            // * Filter with Pseudo
            if (strlen($pseudo)) {
                $query->where('username', 'LIKE', "%{$pseudo}%");
            }
        });
        $req->orderBy('updated_at', 'DESC');

        /** @var \Illuminate\Database\Eloquent\Collection $depsCollection */
        $depsCollection = $req->simplePaginate(15);

        /** @var \App\Models\DepartaimantsCollection $depCollection */
        foreach ($depsCollection as $depCollection) {
            foreach ($depCollection->getAllDepartaimantsWithStatus($collectiontype, $status) as $dep) {
                if (
                    $dep->status->equals($status)
                    // * Filter results with Departaimant
                    and (strlen($departaimant) ? strpos(
                        strtolower(Utils::replaceSpecChar(
                            str_replace(['-', ' ', '\''], '', $dep->departaimant->value() . $dep->departaimant->label())
                        )),
                        $departaimant
                    ) !== false : true)
                    // * Filter results with customer Departaimants
                    and array_key_exists('.' . $dep->departaimant->value(), $userDepStatus)
                ) {
                    $output->add([
                        'departaimantCode' => $dep->departaimant->value(),
                        'departaimant' => $dep->departaimant->label(),
                        'username' => $depCollection->customer->username,
                        'hashcode' => $depCollection->customer->hashcode,
                        'date' => (new NiceDate())->get(null, '', $depCollection->updated_at, [])
                    ]);
                }
            } //end foreach
        } //end foreach

        $output->sortBy('date');

        return response()->json(['status' => 'OK', 'data' => $output->values(), 'page' => 1]);
    }

    /**
     * Undocumented function
     *
     * @param \Illuminate\Support\Collection $departaimantsCollection
     * @return array
     */
    private function getUserDepartaimantsMaps(Collection $departaimantsCollection): array
    {
        $datas = $departaimantsCollection->mapWithKeys(function ($collection) {
            $datas = [];
            foreach ($collection->getAllDepartaimants() as $departaimantItem) {
                $datas[$collection->type->value][] = [
                    'id' => $departaimantItem->departaimant->value(),
                    'name' => $departaimantItem->departaimant->label(),
                    'state' => $departaimantItem->status->value(),
                ];
            }
            return $datas;
        })->toArray();

        return $datas;
    }
}