<?php

namespace App\Services\AtencaoBasica\Avaliacao;

use App\Enums\AtencaoBasica\Avaliacao\Conclusao;
use App\Enums\AtencaoBasica\Avaliacao\Cuidador as EnumCuidador;
use App\Enums\AtencaoBasica\Parametrizacao\Permissao;
use App\Models\AtencaoBasica\Avaliacao\Avaliacao;
use App\Models\AtencaoBasica\Avaliacao\Conclusao as AvaliacaoConclusao;
use App\Models\AtencaoBasica\Avaliacao\Condicao;
use App\Models\AtencaoBasica\Avaliacao\CondicaoAvaliada;
use App\Models\AtencaoBasica\Avaliacao\Cuidador;
use App\Models\AtencaoBasica\Avaliacao\Justificativa;
use App\Models\AtencaoBasica\Avaliacao\JustificativaConclusao;
use App\Models\AtencaoBasica\Avaliacao\Procedencia;
use App\Models\AtencaoBasica\Parametrizacao\Equipe;
use App\Models\AtencaoBasica\Parametrizacao\OutrosPermissaoOcupacao;
use App\Models\Cadastro\Estabelecimento\Infraestrutura;
use App\Models\Cadastro\Estabelecimento\Unidade;
use App\Models\Cadastro\SujeitoAtencao\Paciente;
use App\Models\Cadastro\SujeitoAtencao\Usuario;
use App\Models\Geral\Turno;
use App\Models\Sigtap\Cid;
use App\Models\Sigtap\Ocupacao;
use App\Rules\Cns;
use App\Rules\Cpf;
use App\Services\Service;
use App\Utils\MaskUtil;
use Illuminate\Support\Carbon;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Validator;
use Illuminate\Validation\Rule;

class AvaliacaoService extends Service
{
    public static function create($id)
    {
        $paciente = Paciente::findOrFail($id);
        return [
            'form' => self::getFormData(),
            'model' => self::getModelData($paciente),
        ];
    }

    private static function getFormData()
    {
        return [
            'unidades' => [],
            'infraestruturas' => [],
            'equipes' => [],
            'ocupacoes' => [],
            'turnos' => Turno::orderBy('id')->get(),
            'data_atual' => Carbon::now()->format('d/m/Y'),
            'procedencia' => Procedencia::orderBy('id')->get(),
            'condicoes' => CondicaoAvaliada::orderBy('id')->get(),
            'conclusao' => AvaliacaoConclusao::orderBy('id')->get(),
            'elegivel' => JustificativaConclusao::where('elegivel', true)->orderBy('id')->get(),
            'inelegivel' => JustificativaConclusao::where('elegivel', false)->orderBy('id')->get(),
            'cuidador' => Cuidador::orderBy('id')->get(),
            'cuidador_cns' => null,
            'cuidador_cpf' => null,
        ];
    }

    private static function getModelData($paciente, $avaliacao = null)
    {
        return [
            'avaliacao' => [
                'usuario' => [
                    'id' => $avaliacao->usuario->id ?? null,
                    'cidadao_nome' => $avaliacao->usuario->cidadao->nome ?? null,
                ],
                'unidade_id' => $avaliacao->unidade_id ?? null,
                'infraestrutura_id' => $avaliacao->equipe->infraestrutura_id ?? null,
                'equipe_id' => $avaliacao->equipe_id ?? null,
                'ocupacao_id' => $avaliacao->ocupacao_id ?? null,
                'data' => $avaliacao->data ?? Carbon::now()->format('Y-m-d'),
                'usuario_auxiliar' => [
                    'id' => $avaliacao->usuario_auxiliar_id ?? null,
                    'cidadao_nome' => $avaliacao->usuario_auxiliar->cidadao->nome ?? null,
                ],
                'unidade_auxiliar_id' => $avaliacao->equipe->unidade_auxiliar_id ?? null,
                'equipe_auxiliar_id' => $avaliacao->equipe_auxiliar_id ?? null,
                'ocupacao_auxiliar_id' => $avaliacao->usuario_auxiliar->ocupacao_id ?? null,
            ],
            'cidadao' => [
                'paciente_id' => $paciente->id ?? null,
                'nome' => $paciente->cidadao->nome ?? null,
                'nome_social' => $paciente->cidadao->nome_social ?? null,
                'sexo_id' => $paciente->cidadao->sexo_id ?? null,
                'sexo' => $paciente->cidadao->sexo->descricao ?? null,
                'cns' => $paciente ? MaskUtil::getCnsMasked($paciente->cidadao->cns) : null,
                'cpf' => $paciente ? MaskUtil::getCpfMasked($paciente->cidadao->cpf) : null,
                'data_nascimento' => $paciente->cidadao->data_nascimento->format('Y-m-d') ?? null,
                'idade' => $paciente->cidadao->data_nascimento
                    ? "{$paciente->cidadao->idade['anos']} ano(s), "
                        . "{$paciente->cidadao->idade['meses']} mês(es) e "
                        . "{$paciente->cidadao->idade['dias']} dia(s) "
                    : 'NÃO INFORMADA',
            ],
            'turno' => $avaliacao->turno_id ?? null,
            'procedencia' => $avaliacao->procedencia_id ?? 1,
            'cid_primario' => $avaliacao ? Cid::find($avaliacao->cid_primario) : null,
            'cid_secundario' => $avaliacao ? Cid::find($avaliacao->cid_secundario) : null,
            'cid_terciario' => $avaliacao ? Cid::find($avaliacao->cid_terciario) : null,
            'conclusao' => $avaliacao->conclusao_id ?? null,
            'cuidador' => $avaliacao->cuidador_id ?? 1,
            'cuidador_cns' => $avaliacao ? MaskUtil::getCnsMasked($avaliacao->cns_cuidador) : '',
            'cuidador_cpf' => $avaliacao ? MaskUtil::getCpfMasked($avaliacao->cpf_cuidador) : '',
            'condicoes' => $avaliacao ? Condicao::where('avaliacao_id', $avaliacao->id)->get()->pluck('condicao_id') : [],
            'justificativa' => self::getJustificativa($avaliacao),
            'exportacao' => $avaliacao->exportacao ?? false,
        ];
    }

    private static function getJustificativa($avaliacao)
    {
        if(!$avaliacao) {
            return [];
        }
        $justificativa = Justificativa::where('avaliacao_id', $avaliacao->id)->get()->pluck('justificativa_id');
        if($avaliacao->conclusao_id != Conclusao::INELEGIVEL && $justificativa->count() == 1) {
            return $justificativa[0];
        } else {
            return $justificativa;
        }
    }

    public static function getUnidades()
    {
        return DB::table('atencao_basica_parametrizacao_equipe_usuario AS usuario')
            ->select([
                'unidade.id',
                DB::raw("CONCAT(TRIM(unidade.cnes), ' - ', unidade.nome_fantasia) AS nome_fantasia")
            ])
            ->join('atencao_basica_parametrizacao_equipe as equipe', 'equipe.id', 'usuario.equipe_id')
            ->join('cadastro_unidade as unidade', 'unidade.id', 'equipe.unidade_id')
            ->where('usuario.ativo', true)
            ->when(request()->usuario_id, fn ($q, $id)  => $q->where('usuario.usuario_id', $id))
            ->distinct()
            ->get();
    }

    public static function getInfraestruturas(){

        return DB::table('atencao_basica_parametrizacao_equipe_usuario')
        ->select([
            'cadastro_infraestrutura.id AS id',
            DB::raw('COALESCE(cadastro_infraestrutura.nome, cadastro_unidade.nome_fantasia) AS nome'),
        ])
        ->join('atencao_basica_parametrizacao_equipe', 'atencao_basica_parametrizacao_equipe.id', 'atencao_basica_parametrizacao_equipe_usuario.equipe_id')
        ->join('cadastro_infraestrutura', 'cadastro_infraestrutura.id', 'atencao_basica_parametrizacao_equipe.infraestrutura_id')
        ->join('cadastro_unidade', 'cadastro_unidade.id', 'atencao_basica_parametrizacao_equipe.unidade_id')
        ->where('atencao_basica_parametrizacao_equipe_usuario.ativo', true)
        ->when(request()->usuario_id, fn ($q, $id) => $q->where('atencao_basica_parametrizacao_equipe_usuario.usuario_id', $id))
        ->when(request()->unidade_id, fn ($q, $id) => $q->where('atencao_basica_parametrizacao_equipe.unidade_id', $id))
        ->distinct()
        ->orderBy('nome')
        ->get();
    }

    public static function getEquipes()
    {
        return DB::table('atencao_basica_parametrizacao_equipe_usuario AS usuario')
            ->select([
                'equipe.id AS id',

            DB::raw("
                    CONCAT(
                        CASE
                            WHEN area.numero_ine IS NOT NULL THEN CONCAT('INE: ', area.numero_ine)
                            ELSE ''
                        END,
                        CASE
                            WHEN area.descricao IS NOT NULL AND area.numero_ine IS NOT NULL THEN ' - Área: '
                            WHEN area.descricao IS NOT NULL THEN 'Área: '
                            ELSE ''
                        END,
                        COALESCE(area.descricao, ''),
                        CASE
                            WHEN microarea.descricao IS NOT NULL AND (area.numero_ine IS NOT NULL OR area.descricao IS NOT NULL) THEN ' - Microárea: '
                            WHEN microarea.descricao IS NOT NULL THEN 'Microárea: '
                            ELSE ''
                        END,
                        COALESCE(microarea.descricao, '')
                    ) AS descricao
                ")
            ])
            ->join('atencao_basica_parametrizacao_equipe AS equipe', 'equipe.id', 'usuario.equipe_id')
            ->join('cadastro_unidade AS unidade', 'unidade.id', 'equipe.unidade_id')
            ->leftJoin('atencao_basica_parametrizacao_area AS area', 'area.id', 'equipe.area_id')
            ->leftJoin('atencao_basica_parametrizacao_microarea AS microarea', 'microarea.id', 'equipe.microarea_id')
            ->where('usuario.ativo', true)
            ->when(request()->usuario_id, fn ($q, $id) => $q->where('usuario.usuario_id', $id))
            ->when(request()->infraestrutura_id, fn ($q, $id) => $q->where('equipe.infraestrutura_id', $id))
            ->get();
    }

    public static function getOcupacoes()
    {
        $usuario = Usuario::findOrFail(request()->usuario_id);
        $permissao = OutrosPermissaoOcupacao::where('permissao_id', Permissao::AVALIACAO_ELEGIBILIDADE_ADMISSAO)->get();
        $codigos = $permissao->pluck('ocupacao');

        return $usuario->lotacoes
            ->filter(function ($lotacao) use ($codigos) {
                return $lotacao->infraestrutura->id == request()->infraestrutura_id &&
                    $codigos->contains($lotacao->ocupacao->codigo);
            })
            ->pluck('ocupacao');
    }

    public static function getAvaliacoes($id)
    {
        return DB::table('atencao_basica_avaliacao as avaliacao')
            ->join('cadastro_usuario as usuario', 'usuario.id', 'avaliacao.usuario_id')
            ->join('cadastro_cidadao as profissional', 'profissional.id', 'usuario.cidadao_id')
            ->join('cadastro_paciente as paciente', 'paciente.id', 'avaliacao.paciente_id')
            ->join('cadastro_cidadao as cidadao', 'cidadao.id', 'paciente.cidadao_id')
            ->join('cadastro_unidade as unidade', 'unidade.id', 'avaliacao.unidade_id')
            ->join('atencao_basica_parametrizacao_equipe as equipe', 'equipe.id', 'avaliacao.equipe_id')
            ->join('cadastro_infraestrutura as infraestrutura', 'infraestrutura.id', 'equipe.infraestrutura_id')
            ->leftJoin('cadastro_usuario as usuario_exportacao', 'usuario_exportacao.id', 'avaliacao.usuario_exportacao_id')
            ->leftJoin('cadastro_cidadao as cidadao_exportacao', 'cidadao_exportacao.id', 'usuario_exportacao.cidadao_id')
            ->leftJoin('atencao_basica_exportacao as exportacao', 'exportacao.id', 'avaliacao.exportacao_id')
            ->select(
                'avaliacao.id',
                'avaliacao.data',
                'unidade.nome_fantasia as unidade',
                DB::raw('COALESCE(infraestrutura.nome, unidade.nome_fantasia) AS infraestrutura'),
                'cidadao.cns',
                'profissional.nome as profissional',
                'cidadao_exportacao.nome as profissional_exportacao',
                DB::raw("DATE_FORMAT(exportacao.created_at, '%d/%m/%Y') AS data_exportacao"),
                DB::raw("DATE_FORMAT(exportacao.created_at, '%H:%i') AS horario_exportacao"),
                'avaliacao.exportacao'
            )
            ->where('avaliacao.paciente_id', $id)
            ->get();
    }

    public static function store()
    {

        return self::saveStore(request()->all());
    }

    public static function saveStore($params)
    {

        self::validate($params);

        $avaliacao = Avaliacao::create($params)->fresh();
        
        $params = (object) $params;

        foreach($params->condicoes as $condicao_id) {
            Condicao::create([
                'avaliacao_id' => $avaliacao->id,
                'condicao_id' => $condicao_id
            ]);
        }

        if($avaliacao->conclusao_id == Conclusao::INELEGIVEL) {
            foreach($params->justificativa as $justificativa_id) {
                Justificativa::create([
                    'avaliacao_id' => $avaliacao->id,
                    'justificativa_id' => $justificativa_id,
                ]);
            }
        }else {
            Justificativa::create([
                'avaliacao_id' => $avaliacao->id,
                'justificativa_id' => $params->justificativa
            ]);
        }

        return $avaliacao;
    }

    private static function validate($params)
    {

        return Validator::make($params, [
            'paciente_id' => [
                'required',
                Rule::exists(Paciente::class, 'id')
            ],
            'usuario_id' => [
                'required',
                Rule::exists(Usuario::class, 'id')
            ],
            'equipe_id' => [
                'required',
                Rule::exists(Equipe::class, 'id')
            ],
            'unidade_id' => [
                'required',
                Rule::exists(Unidade::class, 'id')
            ],
            'infraestrutura_id' => [
                'required',
                Rule::exists(Infraestrutura::class, 'id')
            ],
            'ocupacao_id' => [
                'required',
                Rule::exists(Ocupacao::class, 'id')
            ],
            'turno_id' => [
                'required',
                Rule::exists(Turno::class, 'id')
            ],
            'data' => [
                'date',
                'required',
            ],
            'procedencia_id' => [
                'required',
                Rule::exists(Procedencia::class, 'id')
            ],
            'cid_primario' => [
                'required',
                Rule::exists(Cid::class, 'id')
            ],
            'cid_secundario' => [
                'nullable',
                Rule::exists(Cid::class, 'id')
            ],
            'cid_terciario' => [
                'nullable',
                Rule::exists(Cid::class, 'id')
            ],
            'conclusao_id' => [
                'required',
                Rule::exists(AvaliacaoConclusao::class, 'id')
            ],
            'cuidador_id' => [
                'required',
                Rule::exists(Cuidador::class, 'id')
            ],
            'cns_cuidador' =>[
                new Cns,
                'nullable',
                Rule::requiredIf(fn() => $params['cuidador_id'] != EnumCuidador::NAO_POSSUI && $params['cpf_cuidador'] == null)
            ],
            'cpf_cuidador' => [
                new Cpf,
                'nullable',
                Rule::requiredIf(fn() => $params['cuidador_id'] != EnumCuidador::NAO_POSSUI && $params['cns_cuidador'] == null)
            ]
        ])->validate();
    }

    public static function edit($id)
    {
        $avaliacao = Avaliacao::find($id);

        $paciente = $avaliacao->paciente;

        return [
            'form' => self::getFormData(),
            'model' => self::getModelData($paciente, $avaliacao),
        ];
    }

    public static function update($id)
    {

        return self::saveUpdate($id, request()->all());
    }

    public static function saveUpdate($id, $params)
    {
        self::validate($params);

        $avaliacao = Avaliacao::find($id);

        $avaliacao->update($params);

        Condicao::where('avaliacao_id', $id)->delete();

        $params = (object) $params;

        foreach($params->condicoes as $condicao_id) {
            Condicao::create([
                'avaliacao_id' => $avaliacao->id,
                'condicao_id' => $condicao_id
            ]);
        }

        Justificativa::where('avaliacao_id', $id)->delete();

        if($avaliacao->conclusao_id == Conclusao::INELEGIVEL) {
            foreach($params->justificativa as $justificativa_id) {
                Justificativa::create([
                    'avaliacao_id' => $avaliacao->id,
                    'justificativa_id' => $justificativa_id,
                ]);
            }
        }
        else {
            Justificativa::create([
                'avaliacao_id' => $avaliacao->id,
                'justificativa_id' => $params->justificativa
            ]);
        }

        return $avaliacao;
    }

    public static function destroy($id)
    {
        Condicao::where('avaliacao_id', $id)->delete();

        Justificativa::where('avaliacao_id', $id)->delete();

        Avaliacao::destroy($id);
    }
}