<?php

namespace App\Services;

use App\Enums\PartnerAgreementStatusEnum;
use App\Enums\UserStatusEnum;
use App\Enums\UserTypeEnum;
use App\Models\PartnerAgreement;
use App\Models\User;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Pagination\LengthAwarePaginator;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Hash;

class PartnerAgreementService
{
    public function getAll(array $filters = []): Collection
    {
        $query = PartnerAgreement::with(['category', 'city', 'logo'])
            ->orderBy('company_name');

        if (!empty($filters['type'])) {
            $query->where('type', $filters['type']);
        }

        return $query->get();
    }

    public function getAllPaginated(array $filters = [], int $perPage = 10): LengthAwarePaginator
    {
        $query = $this->baseQuery($filters)
            ->with(['category', 'city', 'logo']);

        if (!empty($filters['expires_in_days'])) {
            $query->orderBy('contract_end');
        } else {
            $query->orderBy('company_name');
        }

        if (!empty($filters['status'])) {
            $query->where('status', $filters['status']);
        }

        return $query->paginate($perPage);
    }

    /**
     * Status existentes no conjunto filtrado, desconsiderando o próprio filtro de status.
     *
     * @return array<int, string>
     */
    public function getStatusOptions(array $filters = []): array
    {
        return $this->baseQuery($filters)
            ->toBase()
            ->distinct()
            ->pluck('status')
            ->filter()
            ->values()
            ->all();
    }

    private function baseQuery(array $filters): Builder
    {
        $query = PartnerAgreement::query();

        if (!empty($filters['type'])) {
            $query->where('type', $filters['type']);
        }

        if (!empty($filters['search'])) {
            $term = '%' . mb_strtolower($filters['search']) . '%';
            $query->where(function ($q) use ($term) {
                $q->whereRaw('UNACCENT(LOWER(company_name)) LIKE UNACCENT(?)', [$term])
                  ->orWhereRaw('UNACCENT(LOWER(COALESCE(responsible, \'\'))) LIKE UNACCENT(?)', [$term])
                  ->orWhereRaw('UNACCENT(LOWER(COALESCE(cnpj, \'\'))) LIKE UNACCENT(?)', [$term]);
            });
        }

        if (!empty($filters['expires_in_days'])) {
            $days = (int) $filters['expires_in_days'];
            $query->whereBetween('contract_end', [now()->startOfDay(), now()->addDays($days)->endOfDay()]);
        }

        if (!empty($filters['created_month']) && $filters['created_month'] === 'current') {
            $query->whereMonth('created_at', now()->month)
                  ->whereYear('created_at', now()->year);
        }

        return $query;
    }

    public function getExpiringPaginated(int $days = 30, int $perPage = 10): LengthAwarePaginator
    {
        return PartnerAgreement::with(['category', 'city', 'logo'])
            ->whereNotNull('contract_end')
            ->whereBetween('contract_end', [now()->startOfDay(), now()->addDays($days)->endOfDay()])
            ->orderBy('contract_end')
            ->paginate($perPage);
    }

    public function findById(int $id): ?PartnerAgreement
    {
        return PartnerAgreement::with(['category', 'city', 'state', 'services', 'logo', 'media', 'user'])->find($id);
    }

    public function findByUserId(int $userId): ?PartnerAgreement
    {
        $partner = PartnerAgreement::with(['category', 'city', 'state', 'services', 'logo', 'media'])
            ->where('user_id', $userId)
            ->first();

        if (!$partner) {
          if (PartnerAgreement::onlyTrashed()->where('user_id', $userId)->exists()) {
            return null;
          }

          $partner = new PartnerAgreement();
          $partner->company_name = 'Novo Parceiro';
          $partner->user_id = $userId;
          $partner->save();
          $partner->fresh(['category', 'city', 'state', 'services', 'logo', 'media']);
        }

        return $partner;
    }

    public function findDados(int $id): ?PartnerAgreement
    {
        return PartnerAgreement::with(['category', 'logo'])->find($id);
    }

    public function findContato(int $id): ?PartnerAgreement
    {
        return PartnerAgreement::find($id);
    }

    public function findEndereco(int $id): ?PartnerAgreement
    {
        return PartnerAgreement::with(['city', 'state'])->find($id);
    }

    public function findContrato(int $id): ?PartnerAgreement
    {
        return PartnerAgreement::with(['media'])->find($id);
    }

    public function create(array $data): PartnerAgreement
    {
        $user = User::create([
            'name'     => $data['user_name'],
            'email'    => $data['user_email'],
            'password' => Hash::make($data['user_password']),
            'type'     => UserTypeEnum::PARCEIRO,
        ]);

        $partnerData = collect($data)
            ->except(['user_name', 'user_email', 'user_password'])
            ->put('user_id', $user->id)
            ->all();

        $model = PartnerAgreement::create($partnerData);
        return $model->fresh(['category', 'logo', 'user']);
    }

    public function update(int $id, array $data): ?PartnerAgreement
    {
        $model = PartnerAgreement::find($id);

        if (!$model) {
            return null;
        }

        $model->update($data);
        return $model->fresh(['category', 'city', 'state', 'logo', 'media']);
    }

    public function getTrashed(array $filters = []): Collection
    {
        $query = PartnerAgreement::onlyTrashed()->orderByDesc('deleted_at');

        if (!empty($filters['type'])) {
            $query->where('type', $filters['type']);
        }

        return $query->get(['id', 'company_name', 'type', 'deleted_at']);
    }

    public function restore(int $id): ?PartnerAgreement
    {
        $model = PartnerAgreement::onlyTrashed()->find($id);

        if (!$model) {
            return null;
        }

        return DB::transaction(function () use ($model): PartnerAgreement {
            $model->restore();
            $model->update(['status' => PartnerAgreementStatusEnum::ACTIVE]);
            $model->user?->update(['status' => UserStatusEnum::ACTIVE]);

            return $model->fresh();
        });
    }

    public function delete(int $id): bool
    {
        $model = PartnerAgreement::find($id);

        if (!$model) {
            return false;
        }

        return DB::transaction(function () use ($model): bool {
            $model->services()->delete();

            $model->user?->update(['status' => UserStatusEnum::INACTIVE]);

            $model->update(['status' => PartnerAgreementStatusEnum::INACTIVE]);

            return (bool) $model->delete();
        });
    }
}