<?php

namespace App\Services\Cadastro;

use App\Enums\Sigtap\ProcedimentoCompatibilidade;
use App\Models\Cadastro\Oci;
use App\Services\Service;
use App\Utils\MaskUtil;
use Carbon\Carbon;
use DateTimeImmutable;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\Rule;

class OciService extends Service
{
    public static function datatable()
    {
        return DB::table('cadastro_oci AS oci')
            ->join('sigtap.procedimento AS procedimento', fn ($j) => $j
                ->on('procedimento.codigo', 'oci.procedimento_codigo')
                ->where('competencia_id', DB::table('sigtap.competencia')->max('id'))
            )
            ->select(
                'oci.id',
                'oci.codigo',
                'oci.nome',
                'procedimento.codigo AS procedimento_codigo',
                'procedimento.nome AS procedimento_nome',
                'oci.linha_cuidado',
                DB::raw("0 AS has_vinculos")
            );
    }

    public static function list()
    {
        switch (request()->listar) {

            case 'procedimentos-compativeis': {

                return [
                    'procedimentos_primarios' => self::getProcedimentosPrimarios(request()->procedimento_codigo),
                    'procedimentos_secundarios' => self::getProcedimentosSecundarios(request()->procedimento_codigo),
                ];
            }
        }
    }

    public static function create()
    {
        return [
            'additionals' => self::getAdditionalsData(),
            'form' => self::getFormData(),
            'model' => [
                'codigo' => self::getNovoCodigo(),
                'nome' => null,
                'procedimento_codigo' => null,
                'linha_cuidado' => null,
                'descricao_geral' => null,
                'objetivo_assistencial' => null,
                'ativo' => true,
                'motivo_inativacao' => null,
                'etapas_clinicas' => [],
                'portarias' => [],
                'procedimentos_primarios' => [],
                'procedimentos_secundarios' => [],
                'unidades_executoras' => [],
            ],
        ];
    }

    public static function getNovoCodigo()
    {
        return (int) (new DateTimeImmutable())->format('Uu');
    }

    public static function store()
    {
        self::validate();

        $oci = new Oci();

        DB::transaction(function () use ($oci) {

            $oci->fill(self::getOciParams());
            $oci->save();

            $oci->portarias()->createMany(request()->portarias);
            $oci->etapasClinicas()->sync(request()->etapas_clinicas);
            $oci->procedimentosPrimarios()->createMany(request()->procedimentos_primarios);
            $oci->procedimentosSecundarios()->createMany(request()->procedimentos_secundarios);
            $oci->unidadesExecutoras()->createMany(request()->unidades_executoras);
        });

        return $oci->fresh();
    }

    public static function edit($id)
    {
        $oci = Oci::findOrFail($id);

        return [
            'additionals' => self::getAdditionalsData($oci),
            'form' => self::getFormData($oci),
            'model' => [
                'codigo' => $oci->codigo,
                'nome' => $oci->nome,
                'procedimento_codigo' => $oci->procedimento_codigo,
                'linha_cuidado' => $oci->linha_cuidado,
                'descricao_geral' => $oci->descricao_geral,
                'objetivo_assistencial' => $oci->objetivo_assistencial,
                'ativo' => $oci->ativo,
                'motivo_inativacao' => $oci->motivo_inativacao,
                'portarias' => $oci->portarias->map(fn ($portaria) => [
                    'id' => $portaria->id,
                    'descricao' => $portaria->descricao
                ]),
                'etapas_clinicas' => $oci->etapasClinicas->map(fn ($etapaClinica) => [
                    'etapa_clinica_id' => $etapaClinica->id,
                    'etapa_clinica_nome' => $etapaClinica->nome
                ]),
                'procedimentos_primarios' => $oci->procedimentosPrimarios->map(fn ($procedimento) => [
                    'procedimento_codigo' => $procedimento->procedimento->codigo,
                    'procedimento_descricao' => MaskUtil::getProcedimentoMasked($procedimento->procedimento->codigo)
                        . " - {$procedimento->procedimento->nome}",
                    'has_vinculos' => false, // TODO:
                ]),
                'procedimentos_secundarios' => $oci->procedimentosSecundarios->map(fn ($procedimento) => [
                    'procedimento_codigo' => $procedimento->procedimento->codigo,
                    'procedimento_descricao' => MaskUtil::getProcedimentoMasked($procedimento->procedimento->codigo)
                        . " - {$procedimento->procedimento->nome}",
                    'has_vinculos' => false, // TODO:
                ]),
                'unidades_executoras' => $oci->unidadesExecutoras->map(fn ($unidade) => [
                    'unidade_id' => $unidade->unidade_id,
                    'unidade_nome_fantasia' => $unidade->unidade->nome_fantasia
                ]),
            ],
        ];
    }

    private static function getAdditionalsData($oci = null)
    {
        return [
            'has_atendimentos_em_andamento' => false, // TODO:
        ];
    }

    private static function getFormData($oci = null)
    {
        return [
            'procedimentos_principais' => self::getProcedimentosPrincipais(),
            'etapas_clinicas' => self::getEtapasClinicas(),
            'procedimentos_primarios' => self::getProcedimentosPrimarios($oci->procedimento_codigo ?? null),
            'procedimentos_secundarios' => self::getProcedimentosSecundarios($oci->procedimento_codigo ?? null),
            'unidades' => self::getUnidades(),
        ];
    }

    private static function getProcedimentosPrincipais()
    {
        $procedimentos = DB::table('sigtap.procedimento')
            ->where('competencia_id', DB::table('sigtap.competencia')->max('id'))
            ->where('codigo', 'like', '09%')
            ->select(
                'codigo',
                'nome',
            )
            ->orderByRaw("CONCAT(codigo, ' - ', nome)")
            ->get();

        $procedimentos->each(function ($procedimento) {

            $procedimento->descricao = MaskUtil::getProcedimentoMasked($procedimento->codigo) . " - {$procedimento->nome}";

            unset($procedimento->nome);
        });

        return $procedimentos;
    }

    private static function getEtapasClinicas()
    {
        return DB::table('cadastro_etapa_clinica')
            ->select('id', 'nome')
            ->orderBy('nome')
            ->get();
    }

    private static function getProcedimentosPrimarios($procedimentoOciCodigo = null)
    {
        if (is_null($procedimentoOciCodigo)) {

            return collect();
        }

        $procedimentos = DB::table('sigtap.procedimento AS procedimento')
            ->where('procedimento.competencia_id', DB::table('sigtap.competencia')->max('id'))
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('sigtap.procedimento_registro AS procedimento_registro')
                ->join(
                    'sigtap.procedimento_compativel AS procedimento_compativel',
                    'procedimento_compativel.procedimento_registro_compativel_id',
                    'procedimento_registro.id'
                )
                ->join(
                    'sigtap.procedimento_registro AS oci_procedimento_registro',
                    'oci_procedimento_registro.id',
                    'procedimento_compativel.procedimento_registro_principal_id'
                )
                ->join(
                    'sigtap.procedimento AS oci_procedimento',
                    'oci_procedimento.id',
                    'oci_procedimento_registro.procedimento_id'
                )
                ->whereColumn('procedimento_registro.procedimento_id', 'procedimento.id')
                ->where('procedimento_compativel.compatibilidade', ProcedimentoCompatibilidade::OBRIGATORIO)
                ->where('oci_procedimento.codigo', $procedimentoOciCodigo)
            )
            ->select(
                'procedimento.codigo',
                'procedimento.nome',
            )
            ->orderByRaw("CONCAT(procedimento.codigo, ' - ', procedimento.nome)")
            ->get();

        $procedimentos->each(function ($procedimento) {

            $procedimento->descricao = MaskUtil::getProcedimentoMasked($procedimento->codigo) . " - {$procedimento->nome}";

            unset($procedimento->nome);
        });

        return $procedimentos;
    }

    private static function getProcedimentosSecundarios($procedimentoOciCodigo = null)
    {
        if (is_null($procedimentoOciCodigo)) {

            return collect();
        }

        $procedimentos = DB::table('sigtap.procedimento AS procedimento')
            ->where('procedimento.competencia_id', DB::table('sigtap.competencia')->max('id'))
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('sigtap.procedimento_registro AS procedimento_registro')
                ->join(
                    'sigtap.procedimento_compativel AS procedimento_compativel',
                    'procedimento_compativel.procedimento_registro_compativel_id',
                    'procedimento_registro.id'
                )
                ->join(
                    'sigtap.procedimento_registro AS oci_procedimento_registro',
                    'oci_procedimento_registro.id',
                    'procedimento_compativel.procedimento_registro_principal_id'
                )
                ->join(
                    'sigtap.procedimento AS oci_procedimento',
                    'oci_procedimento.id',
                    'oci_procedimento_registro.procedimento_id'
                )
                ->whereColumn('procedimento_registro.procedimento_id', 'procedimento.id')
                ->where('procedimento_compativel.compatibilidade', ProcedimentoCompatibilidade::COMPATIVEL)
                ->where('oci_procedimento.codigo', $procedimentoOciCodigo)
            )
            ->select(
                'procedimento.codigo',
                'procedimento.nome',
            )
            ->orderByRaw("CONCAT(procedimento.codigo, ' - ', procedimento.nome)")
            ->get();

        $procedimentos->each(function ($procedimento) {

            $procedimento->descricao = MaskUtil::getProcedimentoMasked($procedimento->codigo) . " - {$procedimento->nome}";

            unset($procedimento->nome);
        });

        return $procedimentos;
    }

    private static function getUnidades()
    {
        return DB::table('cadastro_unidade')
            ->whereNull('deleted_at')
            ->select('id', 'nome_fantasia')
            ->orderBy('nome_fantasia')
            ->get();
    }

    public static function update($id)
    {
        $oci = Oci::findOrFail($id);

        self::validate();

        DB::transaction(function () use ($oci) {

            $oci->update(self::getOciParams($oci));
            $oci->refresh();

            $oci->etapasClinicas()->sync(request()->etapas_clinicas);

            self::savePortarias($oci);
            self::saveProcedimentosPrimarios($oci);
            self::saveProcedimentosSecundarios($oci);
            self::saveUnidadesExecutoras($oci);
        });

        return $oci->fresh();
    }

    private static function validate()
    {
        return request()->validate([
            'codigo' => [
                'required',
                'digits:16',
                Rule::unique(Oci::class, 'codigo')->ignore(request()->route('oci')),
            ],
            'nome' => [
                'required',
                'string',
                'max:80',
                Rule::unique(Oci::class, 'nome')->ignore(request()->route('oci')),
            ],
            'procedimento_codigo' => [
                'required',
                'string',
                'digits:10',
            ],
            'linha_cuidado' => [
                'nullable',
                'string',
                'max:100',
            ],
            'descricao_geral' => [
                'nullable',
                'string',
                'max:1000',
            ],
            'objetivo_assistencial' => [
                'nullable',
                'string',
                'max:1000',
            ],
            'ativo' => [
                'required',
                'boolean'
            ],
            'motivo_inativacao' => [
                'nullable',
                'required_if:ativo,false',
                'string',
                'max:500',
            ],
            'etapas_clinicas' => [
                'required',
                'array'
            ],
            'etapas_clinicas.*' => [
                'required',
                'integer',
                'distinct',
            ],
            'portarias' => [
                'present',
                'array',
            ],
            'portarias.*.descricao' => [
                'required',
                'string',
                'max:100',
                'distinct',
            ],
            'procedimentos_primarios' => [
                'present',
                'array'
            ],
            'procedimentos_primarios.*.procedimento_codigo' => [
                'required',
                'string',
                'digits:10'
            ],
            'procedimentos_secundarios' => [
                'present',
                'array'
            ],
            'procedimentos_secundarios.*.procedimento_codigo' => [
                'required',
                'string',
                'digits:10'
            ],
            'unidades_executoras' => [
                'required',
                'array'
            ],
            'unidades_executoras.*.unidade_id' => [
                'required',
                'integer',
                'distinct',
            ],
        ], [
            'codigo.unique' => 'O código da OCI já foi inserido anteriormente.',
            'nome.unique' => 'O nome da OCI já foi inserido anteriormente.',
        ]);
    }

    private static function getOciParams($oci = null)
    {
        $params = [
            'nome' => request()->nome,
            'linha_cuidado' => request()->linha_cuidado,
            'descricao_geral' => request()->descricao_geral,
            'objetivo_assistencial' => request()->objetivo_assistencial,
            'ativo' => request()->ativo,
        ];

        if (request()->ativo) {

            $params['motivo_inativacao'] = null;
            $params['inativado_em'] = null;
            $params['inativacao_lotacao_id'] = null;
        }
        else {

            $params['motivo_inativacao'] = request()->motivo_inativacao;
            $params['inativado_em'] = Carbon::now();
            $params['inativacao_lotacao_id'] = self::getCurrentLotacao()->id;
        }

        if (is_null($oci)) {

            $params['codigo'] = request()->codigo;
            $params['procedimento_codigo'] = request()->procedimento_codigo;
        }
        else if (!self::ociHasVinculos($oci)) {

            $params['procedimento_codigo'] = request()->procedimento_codigo;
        }

        return $params;
    }

    private static function ociHasVinculos($oci)
    {
        // TODO:
        return false;
    }

    private static function savePortarias($oci)
    {
        $oci->portarias()->whereNotIn('id', collect(request()->portarias)->pluck('id')->filter())->delete();

        collect(request()->portarias)->each(function ($portaria) use ($oci) {

            $oci->portarias()->updateOrCreate(
                ['id' => $portaria['id']],
                $portaria
            );
        });
    }

    private static function saveProcedimentosPrimarios($oci)
    {
        $oci->procedimentosPrimarios()
            ->whereNotIn('procedimento_codigo', collect(request()->procedimentos_primarios)->pluck('procedimento_codigo'))
            ->delete();

        collect(request()->procedimentos_primarios)->each(function ($procedimento) use ($oci) {

            $oci->procedimentosPrimarios()->updateOrCreate(['procedimento_codigo' => $procedimento['procedimento_codigo']]);
        });
    }

    private static function saveProcedimentosSecundarios($oci)
    {
        $oci->procedimentosSecundarios()
            ->whereNotIn('procedimento_codigo', collect(request()->procedimentos_secundarios)->pluck('procedimento_codigo'))
            ->delete();

        collect(request()->procedimentos_secundarios)->each(function ($procedimento) use ($oci) {

            $oci->procedimentosSecundarios()->updateOrCreate(['procedimento_codigo' => $procedimento['procedimento_codigo']]);
        });
    }

    private static function saveUnidadesExecutoras($oci)
    {
        $oci->unidadesExecutoras()
            ->whereNotIn('unidade_id', collect(request()->unidades_executoras)->pluck('unidade_id'))
            ->delete();

        collect(request()->unidades_executoras)->each(function ($unidadeExecutora) use ($oci) {

            $oci->unidadesExecutoras()->updateOrCreate(['unidade_id' => $unidadeExecutora['unidade_id']]);
        });
    }

    public static function destroy($id)
    {
        Oci::findOrFail($id)->delete();
    }
}