<?php

namespace App\Services;

use App\Models\ExistingBusiness;
use App\Models\User;
use App\Policies\ExistingBusinessPolicy;
use App\Services\Mne\BusinessRepository;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Support\Facades\Crypt;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Gate;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Str;
use Illuminate\Validation\Rule;
use Illuminate\Validation\ValidationException;

/** Supplement of the same UUID. All state remains in the existing immutable encrypted journal. */
class ExistingBusinessClassification
{
    public const VERSION = 'business-classification-20261016-v1';
    private const ACTIONS = ['classification_prepared', 'classification_reviewed', 'classification_disclosed', 'classification_withdrawn'];

    public function context(ExistingBusiness $business): array
    {
        $revision = DB::table('existing_business_revisions')->where('business_id', $business->id)->whereIn('action', self::ACTIONS)->orderByDesc('version_no')->first(['snapshot']);
        if (! $revision) {
            return ['schema_version' => self::VERSION, 'relations' => [], 'authors' => [], 'decisions' => [], 'publication' => []];
        }
        $state = json_decode(Crypt::decryptString($revision->snapshot), true, 512, JSON_THROW_ON_ERROR)['context']['multidimensional'] ?? null;
        abort_unless(is_array($state) && ($state['schema_version'] ?? '') === self::VERSION, 409, 'Versão do suplemento não reconhecida; preserve o histórico.');

        return $state;
    }

    private function hash(array $row): string
    {
        return OpportunityCanonicalValue::hash($row);
    }

    private function evidence(array $row, ExistingBusiness $business): ?array
    {
        $id = $row['classification']['document_id'] ?? null;
        if (! $id) {
            return null;
        }
        $document = DB::table('existing_business_document_links as l')->join('documents as d', 'd.id', '=', 'l.document_id')
            ->where('l.existing_business_id', $business->id)->where('d.id', $id)
            ->first(['l.id as link_id', 'd.id', 'd.sha256', 'd.version_no', 'd.status', 'd.deleted_at', 'd.valid_until', 'd.malware_scan_status', 'd.malware_scanned_sha256']);

        return $document ? (array) $document : ['unavailable' => $id];
    }

    private function evidenceHash(array $row, ExistingBusiness $business): ?string
    {
        $evidence = $this->evidence($row, $business);

        return $evidence === null ? null : OpportunityCanonicalValue::hash($evidence);
    }

    private function validateRows(array $rows, ExistingBusiness $business, bool $confirming = false): void
    {
        $seen = [];
        foreach ($rows as $i => $row) {
            $fail = fn ($key, $message) => throw ValidationException::withMessages(['canonical.relations.'.$i.'.'.$key => $message]);
            Validator::make($row, [
                'related_id' => ['required', 'string', 'max:80'], 'relation_type' => ['required', 'string', 'max:80'],
                'classification' => ['required', 'array:target_type,purpose,criteria,justification,source_reference,citation,document_id,authority_id,requested_state,disclosure,valid_from,valid_until,external_status,external_act_reference,production_stage'],
                'classification.target_type' => ['required', Rule::in(array_keys(OpportunityClassification::TARGETS))],
                'classification.purpose' => ['required', Rule::in(array_keys(OpportunityClassification::PURPOSES))],
                'classification.requested_state' => ['required', Rule::in(['draft', 'preliminary', 'in_validation'])],
                'classification.disclosure' => ['required', Rule::in(['restricted', 'public'])],
                'classification.criteria' => ['nullable', 'string', 'max:2000'], 'classification.justification' => ['nullable', 'string', 'max:4000'],
                'classification.source_reference' => ['nullable', 'string', 'max:2000'], 'classification.citation' => ['nullable', 'string', 'max:1000'],
                'classification.document_id' => ['nullable', 'uuid'], 'classification.authority_id' => ['nullable', 'uuid'],
                'classification.valid_from' => ['nullable', 'date_format:Y-m-d'], 'classification.valid_until' => ['nullable', 'date_format:Y-m-d'],
                'classification.external_status' => ['required', Rule::in(OpportunityClassification::EXTERNAL)],
                'classification.external_act_reference' => ['nullable', 'string', 'max:2000'], 'classification.production_stage' => ['nullable', 'string', 'max:250'],
            ])->validate();
            if (array_diff(array_keys($row), ['related_id', 'relation_type', 'classification'])) {
                $fail('classification', 'Metadados de decisão ou campos desconhecidos não podem ser enviados pelo autor.');
            }
            $c = $row['classification']; $kind = $c['target_type'];
            if (($kind === 'sector' && ! ctype_digit($row['related_id'])) || ($kind !== 'sector' && ! Str::isUuid($row['related_id']))) {
                $fail('related_id', 'Identificador de referência inválido.');
            }
            if (! app(OpportunityClassification::class)->canRetainReference($kind, $row['related_id'], $row, $this->context($business)['relations'])) {
                $fail('related_id', 'Selecione uma referência existente e consultável.');
            }
            if (in_array($c['purpose'], ['regime_recognition', 'enterprise_admission', 'specific_benefit'], true) && $kind !== 'zone') {
                $fail('classification.purpose', 'Regime, admissão e benefício usam a relação regulatória com a zona.');
            }
            $identity = OpportunityClassification::TARGETS[$kind][0].':'.$row['related_id'].':'.$c['purpose'];
            if (isset($seen[$identity])) { $fail('related_id', 'Referência e finalidade já associadas; recupere a relação existente.'); }
            $seen[$identity] = true;
            if (! empty($c['valid_from']) && ! empty($c['valid_until']) && $c['valid_until'] < $c['valid_from']) {
                $fail('classification.valid_until', 'O fim da vigência precede o início.');
            }
            if (! empty($c['authority_id']) && ! DB::table('authorities')->where('id', $c['authority_id'])->where('status', 'published')->exists()) {
                $fail('classification.authority_id', 'Entidade competente não consta do catálogo publicado.');
            }
            $evidence = $this->evidence($row, $business);
            if ($evidence && isset($evidence['unavailable'])) { $fail('classification.document_id', 'Documento não está associado a este anúncio.'); }
            if (($c['external_status'] ?? '') === 'documented_granted' && (empty($c['document_id']) || empty(trim($c['external_act_reference'] ?? '')))) {
                $fail('classification.external_act_reference', 'Um ato declarado como concedido exige documento e referência próprios.');
            }
            if ($confirming) {
                foreach (['criteria', 'justification', 'source_reference', 'citation'] as $key) {
                    if (empty(trim($c[$key] ?? ''))) { $fail('classification.'.$key, 'Confirmação exige fundamento e fonte/citação por relação; a preparação pode continuar preliminar.'); }
                }
                if ($evidence && ($evidence['status'] !== 'active' || $evidence['deleted_at'] !== null || $evidence['malware_scan_status'] !== 'clean'
                    || ! hash_equals(trim($evidence['sha256']), trim((string) $evidence['malware_scanned_sha256']))
                    || (! empty($evidence['valid_until']) && $evidence['valid_until'] < today()->toDateString()))) {
                    $fail('classification.document_id', 'O suporte associado não está disponível, íntegro e analisado para esta confirmação.');
                }
            }
        }
    }

    private function effective(ExistingBusiness $business, array $row, array $state): string
    {
        $decision = $state['decisions'][$this->hash($row)] ?? null;
        if (! $decision) { return $row['classification']['requested_state'] ?? 'preliminary'; }
        if ($decision['state'] !== 'confirmed') { return $decision['state']; }
        $dimension = OpportunityClassification::TARGETS[$row['classification']['target_type']][2];
        $reviewer = User::find($decision['actor_id']);
        if (! $reviewer || ! app(ExistingBusinessPolicy::class)->classificationReviewerScope($reviewer, $business, $dimension)
            || (int) ($state['authors'][$this->hash($row)] ?? 0) === (int) $reviewer->id
            || ($decision['evidence_hash'] ?? null) !== $this->evidenceHash($row, $business)) {
            return 'in_validation';
        }

        return 'confirmed';
    }

    public function privateView(User $actor, ExistingBusiness $business): array
    {
        Gate::forUser($actor)->authorize('view', $business);
        $state = $this->context($business);
        $rows = [];
        foreach ($state['relations'] as $row) {
            $hash = $this->hash($row); $dimension = OpportunityClassification::TARGETS[$row['classification']['target_type']][2];
            $rows[] = ['hash' => $hash, 'relation' => $row, 'dimension' => $dimension, 'state' => $this->effective($business, $row, $state),
                'can_review' => Gate::forUser($actor)->allows('reviewClassification', $business) && app(ExistingBusinessPolicy::class)->classificationReviewerScope($actor, $business, $dimension)
                    && (int) ($state['authors'][$hash] ?? 0) !== (int) $actor->id,
                'history' => $state['decisions'][$hash]['history'] ?? []];
        }
        $documents = DB::table('existing_business_document_links as l')->join('documents as d', 'd.id', '=', 'l.document_id')
            ->where('l.existing_business_id', $business->id)->whereNull('d.deleted_at')->get(['d.id', 'd.file_name', 'd.sha256']);

        return ['id' => $business->id, 'title' => $business->public_title, 'status' => $business->status, 'version_no' => $business->version_no,
            'rows' => $rows, 'publication' => $this->publicRows($business), 'publication_version' => $state['publication_version'] ?? null,
            'preview' => $this->publicRows($business, [...$state, 'publication' => array_values(array_filter($state['relations'], fn ($r) => $r['classification']['disclosure'] === 'public'))]),
            'can_prepare' => Gate::forUser($actor)->allows('prepareClassification', $business),
            'can_disclose' => Gate::forUser($actor)->allows('discloseClassification', $business),
            'options' => app(OpportunityClassification::class)->options(),
            'authorities' => DB::table('authorities')->where('status', 'published')->orderBy('label_pt_mz')->get(['id', 'label_pt_mz']),
            'documents' => $documents->map(fn ($d) => ['id' => $d->id, 'payload' => ['title' => $d->file_name], 'file' => ['file_name' => $d->file_name]])];
    }

    public function act(User $actor, string $id, array $input): ExistingBusiness
    {
        $data = Validator::make($input, [
            'action' => ['required', Rule::in(['prepare', 'review', 'disclose', 'withdraw'])], 'version_no' => ['required', 'integer', 'min:1'],
            'reason' => ['required', 'string', 'min:20', 'max:1000'],
            'rows' => ['required_if:action,prepare', 'array', 'max:100'],
            'hash' => ['required_if:action,review', 'string', 'size:64'],
            'state' => ['required_if:action,review', Rule::in(['in_validation', 'confirmed', 'rejected', 'archived', 'revoked'])],
        ], ['reason.required' => 'Indique o fundamento da ação.', 'reason.min' => 'O fundamento deve ter pelo menos 20 caracteres.'])->validate();
        abort_if(array_diff(array_keys($input), ['action', 'version_no', 'reason', 'rows', 'hash', 'state']), 422, 'Esta ação aceita apenas campos da classificação.');

        return DB::transaction(function () use ($actor, $id, $data) {
            $business = app(BusinessRepository::class)->find($id, true);
            $action = $data['action'];
            Gate::forUser($actor)->authorize(match ($action) { 'prepare' => 'prepareClassification', 'review' => 'reviewClassification', default => 'discloseClassification' }, $business);
            abort_unless($business->version_no === (int) $data['version_no'], 409, 'A versão mudou. Atualize antes de decidir; preserve os valores preparados.');
            $state = $this->context($business);
            if ($action === 'prepare') {
                $this->validateRows($data['rows'], $business);
                $state['relations'] = $data['rows'];
                foreach ($data['rows'] as $row) { $state['authors'][$this->hash($row)] ??= $actor->id; }
            } elseif ($action === 'review') {
                $search = in_array($data['state'], ['revoked', 'archived'], true) ? [...$state['relations'], ...$state['publication']] : $state['relations'];
                $row = collect($search)->first(fn ($r) => hash_equals($this->hash($r), $data['hash']));
                abort_unless($row, 409, 'Associação inexistente nesta versão.');
                $dimension = OpportunityClassification::TARGETS[$row['classification']['target_type']][2];
                abort_unless(app(ExistingBusinessPolicy::class)->classificationReviewerScope($actor, $business, $dimension)
                    && (int) ($state['authors'][$data['hash']] ?? 0) !== (int) $actor->id, 403, 'Revisão exige responsabilidade e independência aplicáveis.');
                if ($data['state'] === 'confirmed') { $this->validateRows([$row], $business, true); }
                $prior = $state['decisions'][$data['hash']] ?? [];
                $decision = ['state' => $data['state'], 'actor_id' => $actor->id, 'at' => now()->toIso8601String(), 'reason' => $data['reason'],
                    'evidence_hash' => $this->evidenceHash($row, $business), 'version' => ($prior['version'] ?? 0) + 1];
                $state['decisions'][$data['hash']] = [...$decision, 'history' => [...($prior['history'] ?? []), $decision]];
                if (in_array($data['state'], ['revoked', 'archived'], true)) {
                    // Explicit withdrawal is retained: a later confirmation must not silently republish it.
                    $state['publication'] = array_values(array_filter($state['publication'], fn ($r) => $this->hash($r) !== $data['hash']));
                }
            } else {
                $publication = $action === 'withdraw' ? [] : array_values(array_filter($state['relations'], fn ($r) => $r['classification']['disclosure'] === 'public'));
                $this->validateRows($publication, $business);
                // Existing publication independence also applies to the actors deciding this supplement.
                foreach ($publication as $row) {
                    abort_if((int) ($state['decisions'][$this->hash($row)]['actor_id'] ?? 0) === (int) $actor->id, 403, 'A divulgação deve ser feita por pessoa diferente de quem decidiu a associação.');
                }
                $state['publication'] = $publication;
                $state['publication_version'] = $business->version_no + 1;
                $state['publication_actor'] = $actor->id;
                $state['publication_at'] = now()->toIso8601String();
            }
            $business->version_no++;
            $business->save();
            $event = ['prepare' => 'classification_prepared', 'review' => 'classification_reviewed', 'disclose' => 'classification_disclosed', 'withdraw' => 'classification_withdrawn'][$action];
            app(ExistingBusinessDrafts::class)->snapshot($business, $actor, $event, $data['reason'], ['multidimensional' => $state]);

            return $business;
        });
    }

    public function publicRows(ExistingBusiness $business, ?array $preparedState = null): array
    {
        if ($business->trashed() || $business->status !== 'published' || ! $business->published_at || $business->published_at->isFuture()
            || ($business->expires_at && $business->expires_at->isBefore(today()))) { return []; }
        $state = $preparedState ?? $this->context($business); $rows = [];
        foreach ($state['publication'] as $row) {
            $c = $row['classification']; $kind = $c['target_type'];
            if (($c['disclosure'] ?? '') !== 'public' || ! isset(OpportunityClassification::TARGETS[$kind])) { continue; }
            $target = app(OpportunityClassification::class)->targets($kind)->where('id', $row['related_id'])->first();
            if (! $target || (! empty($c['valid_from']) && $c['valid_from'] > today()->toDateString()) || (! empty($c['valid_until']) && $c['valid_until'] < today()->toDateString())) { continue; }
            $effective = $this->effective($business, $row, $state);
            if (in_array($effective, ['archived', 'revoked'], true)) { continue; }
            $rows[] = ['dimension' => OpportunityClassification::TARGETS[$kind][2], 'target_type' => $kind, 'target_id' => (string) $row['related_id'],
                'label' => $target->{OpportunityClassification::TARGETS[$kind][1]}, 'target_code' => $target->code ?? null,
                'reference_path' => $kind === 'activity' ? (app(EconomicReferenceCatalog::class)->activities()->firstWhere('id', $target->id)?->path ?? []) : [], 'purpose' => $c['purpose'], 'purpose_label' => OpportunityClassification::PURPOSES[$c['purpose']],
                'state' => $effective, 'source_reference' => $c['source_reference'] ?? null, 'citation' => $c['citation'] ?? null,
                'authority_id' => $c['authority_id'] ?? null, 'production_stage' => $c['production_stage'] ?? null,
                'external_status' => $c['external_status'], 'valid_from' => $c['valid_from'] ?? null, 'valid_until' => $c['valid_until'] ?? null];
        }

        return $rows;
    }

    public function filterRules(): array
    {
        return ['association_type' => ['nullable', Rule::in(array_keys(OpportunityClassification::TARGETS))],
            'association_target' => ['nullable', 'string', 'max:80'], 'association_purpose' => ['nullable', Rule::in(array_keys(OpportunityClassification::PURPOSES))],
            'association_state' => ['nullable', Rule::in(OpportunityClassification::STATES)],
            'chain_id' => ['nullable', 'uuid'], 'authority_id' => ['nullable', 'uuid'], 'subsector_id' => ['nullable', 'uuid']];
    }

    public function constrain(Builder $query, array $filters): void
    {
        $filters = array_filter(array_intersect_key($filters, $this->filterRules()), fn ($v) => $v !== null && $v !== '');
        if ($filters === []) { return; }
        $ids = [];
        (clone $query)->reorder()->select('existing_businesses.*')->chunkById(200, function ($records) use ($filters, &$ids) {
            foreach ($records as $business) {
                $rows = $this->publicRows($business); $same = array_intersect_key($filters, array_flip(['association_type', 'association_target', 'association_purpose', 'association_state']));
                $matches = ! $same || collect($rows)->contains(function ($row) use ($same) {
                    foreach (['association_type' => 'target_type', 'association_target' => 'target_id', 'association_purpose' => 'purpose', 'association_state' => 'state'] as $key => $field) {
                        if (isset($same[$key]) && $same[$key] !== $row[$field]) { return false; }
                    }
                    return true;
                });
                foreach (['chain_id' => 'chain', 'subsector_id' => 'activity'] as $key => $type) {
                    if (! empty($filters[$key])) { $matches = $matches && collect($rows)->contains(fn ($r) => $r['target_type'] === $type && $r['target_id'] === $filters[$key]); }
                }
                if (! empty($filters['authority_id'])) { $matches = $matches && collect($rows)->contains(fn ($r) => ($r['authority_id'] ?? null) === $filters['authority_id']); }
                if ($matches) { $ids[] = $business->id; }
            }
        }, 'existing_businesses.id', 'id');
        $query->whereIn('existing_businesses.id', $ids);
    }
}