<?php

namespace App\Services\AtencaoBasica\FichaVacinacao;

use App\Enums\AtencaoBasica\AtendimentoIndividual\LocalAtendimento as AtendimentoIndividualLocalAtendimento;
use App\Enums\Imunizacao\Estrategia as EnumEstrategia;
use App\Enums\Imunizacao\Produtor as EnumProdutor;
use App\Enums\Cadastro\VacinaCodigo;
use App\Enums\AtencaoBasica\Parametrizacao\Permissao;
use App\Enums\Imunizacao\Estrategia as ImunizacaoEstrategia;
use App\Enums\Imunizacao\SaidaTipo;
use App\Exceptions\AtencaoBasica\AtendimentoOdontologico\ExportedException;
use App\Exceptions\AtencaoBasica\FichaVacinacao\CnsException;
use App\Exceptions\AtencaoBasica\FichaVacinacao\DoseException;
use App\Exceptions\AtencaoBasica\FichaVacinacao\EstrategiaException;
use App\Exceptions\AtencaoBasica\FichaVacinacao\ProdutorException;
use App\Models\AtencaoBasica\FichaVacinacao\FichaVacinacao;
use App\Models\AtencaoBasica\FichaVacinacao\PacienteItem;
use App\Models\AtencaoBasica\FichaVacinacao\VacinacaoPaciente;
use App\Models\AtencaoBasica\FichaVacinacao\VacinacaoRegra;
use App\Models\AtencaoBasica\MarcadorConsumoAlimentar\LocalAtendimento;
use App\Models\AtencaoBasica\Parametrizacao\Equipe;
use App\Models\AtencaoBasica\Parametrizacao\OutrosPermissaoOcupacao;
use App\Models\Cadastro\Estabelecimento\Unidade;
use App\Models\Cadastro\SujeitoAtencao\Paciente;
use App\Models\Cadastro\SujeitoAtencao\Usuario;
use App\Models\Cadastro\Vacina;
use App\Models\Geral\Turno;
use App\Models\Imunizacao\Dose;
use App\Models\Imunizacao\EntradaVacina;
use App\Models\Imunizacao\Estrategia;
use App\Models\Imunizacao\GrupoAtendimento;
use App\Models\Imunizacao\Parametrizacao;
use App\Models\Imunizacao\Produtor;
use App\Models\Imunizacao\RegistroAplicacao;
use App\Models\Imunizacao\RegistroAtualizacao;
use App\Models\Imunizacao\Saida;
use App\Models\Imunizacao\SaidaVacina;
use App\Models\Imunizacao\SalaVacinacao;
use App\Models\Sigtap\Ocupacao;
use App\Services\Service;
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\Rule;

class FichaVacinacaoService extends Service
{
    public static function index()
    {
        return [
            'model' => [
                'data_inicial' => null,
                'data_final' => null,
                'unidade' => null,
                'profissional' => null
            ],
            'form' => [
                'unidades' => [],
                'profissionais' => [],
            ]
        ];
    }

    public static function list()
    {
        return DB::table('atencao_basica_ficha_vacinacao as ficha_vacinacao')
            ->select(
                'ficha_vacinacao.id',
                'ficha_vacinacao.data_atendimento as data',
                'cidadao.nome as profissional',
                'unidade.nome_fantasia as unidade',
                DB::raw('IF(ficha_vacinacao.uuid_ficha, TRUE, FALSE) as exportado'),
                '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"),
            )
            ->join('cadastro_usuario as usuario', 'usuario.id', 'ficha_vacinacao.usuario_id')
            ->join('cadastro_cidadao as cidadao', 'cidadao.id', 'usuario.cidadao_id')
            ->join('atencao_basica_parametrizacao_equipe as equipe', 'equipe.id', 'ficha_vacinacao.equipe_id')
            ->join('cadastro_unidade as unidade', 'unidade.id', 'equipe.unidade_id')
            ->leftJoin('cadastro_usuario as usuario_exportacao', 'usuario_exportacao.id', 'ficha_vacinacao.usuario_exportacao_id')
            ->leftJoin('cadastro_cidadao as cidadao_exportacao', 'cidadao_exportacao.id', 'usuario_exportacao.cidadao_id')
            ->leftJoin('atencao_basica_exportacao as exportacao', 'exportacao.id', 'ficha_vacinacao.exportacao_id')
            ->where('ficha_vacinacao.data_atendimento', '>=', request()->data_inicial)
            ->where('ficha_vacinacao.data_atendimento', '<=', request()->data_final)
            ->when(request()->unidade_id, fn($q) => $q->where('equipe.unidade_id', request()->unidade_id))
            ->when(request()->profissional_id, fn($q) => $q->where('ficha_vacinacao.usuario_id', request()->profissional_id))
            ->get();
    }

    public static function getUnidades()
    {
        return DB::table('atencao_basica_parametrizacao_equipe_usuario as usuario')
            ->select([
                'cadastro_unidade.id AS id',
                DB::raw("CONCAT(TRIM(cadastro_unidade.cnes), ' - ',  cadastro_unidade.nome_fantasia ) AS nome_fantasia"),
            ])
            ->join('atencao_basica_parametrizacao_equipe as equipe', 'equipe.id', 'usuario.equipe_id')
            ->leftJoin('atencao_basica_ficha_vacinacao as ficha', 'ficha.equipe_id', 'equipe.id')
            ->join('cadastro_unidade', 'cadastro_unidade.id', 'equipe.unidade_id')
            ->where('usuario.ativo', true)
            ->when(request()->usuario_id, fn ($q, $id) => $q->where('usuario.usuario_id', $id))
            ->when(request()->data_inicial, fn($q) => $q->where('ficha.data_atendimento', '>=', request()->data_inicial))
            ->when(request()->data_final, fn($q) => $q->where('ficha.data_atendimento', '<=', request()->data_final))
            ->groupBy('id')
            ->orderBy('nome_fantasia')
            ->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 getProfissionais()
    {
        return DB::table('atencao_basica_ficha_vacinacao as ficha')
            ->select([
                'usuario.id',
                'cidadao.nome'
            ])
            ->join('atencao_basica_parametrizacao_equipe as equipe', 'equipe.id', 'ficha.equipe_id')
            ->join('cadastro_unidade as unidade', 'unidade.id', 'equipe.unidade_id')
            ->join('cadastro_usuario as usuario', 'usuario.id', 'ficha.usuario_id')
            ->join('cadastro_cidadao as cidadao', 'cidadao.id', 'usuario.cidadao_id')
            ->where('ficha.data_atendimento', '>=', request()->data_inicial)
            ->where('ficha.data_atendimento', '<=', request()->data_final)
            ->when(request()->unidade_id, function($query) {
                $query->where('unidade.id', request()->unidade_id);
            })
            ->groupBy('usuario.id')
            ->orderBy('cidadao.nome')
            ->get();
    }

    public static function getEquipes()
    {
        if (request()->sala_vacinacao_id) {
            $sala_vacinacao = SalaVacinacao::find(request()->sala_vacinacao_id);
            $infraestrutrua_id = $sala_vacinacao->infraestrutura_id;
        } else {
            $infraestrutrua_id = request()->infraestrutura_id;
        }

        return DB::table('atencao_basica_parametrizacao_equipe_usuario')
            ->select([
                'atencao_basica_parametrizacao_equipe.id AS id',
                DB::raw("
                    CONCAT(
                        CASE
                            WHEN atencao_basica_parametrizacao_area.numero_ine IS NOT NULL THEN CONCAT('INE: ', atencao_basica_parametrizacao_area.numero_ine)
                            ELSE ''
                        END,
                        CASE
                            WHEN atencao_basica_parametrizacao_area.descricao IS NOT NULL AND atencao_basica_parametrizacao_area.numero_ine IS NOT NULL THEN ' - Área: '
                            WHEN atencao_basica_parametrizacao_area.descricao IS NOT NULL THEN 'Área: '
                            ELSE ''
                        END,
                        COALESCE(atencao_basica_parametrizacao_area.descricao, ''),
                        CASE
                            WHEN atencao_basica_parametrizacao_microarea.descricao IS NOT NULL AND (atencao_basica_parametrizacao_area.numero_ine IS NOT NULL OR atencao_basica_parametrizacao_area.descricao IS NOT NULL) THEN ' - Microárea: '
                            WHEN atencao_basica_parametrizacao_microarea.descricao IS NOT NULL THEN 'Microárea: '
                            ELSE ''
                        END,
                        COALESCE(atencao_basica_parametrizacao_microarea.descricao, '')
                    ) AS descricao
                ")
            ])
            ->join('atencao_basica_parametrizacao_equipe', 'atencao_basica_parametrizacao_equipe.id', 'atencao_basica_parametrizacao_equipe_usuario.equipe_id')
            ->join('cadastro_unidade', 'cadastro_unidade.id', 'atencao_basica_parametrizacao_equipe.unidade_id')
            ->leftJoin('atencao_basica_parametrizacao_area', 'atencao_basica_parametrizacao_area.id', 'atencao_basica_parametrizacao_equipe.area_id')
            ->leftJoin('atencao_basica_parametrizacao_microarea', 'atencao_basica_parametrizacao_microarea.id', 'atencao_basica_parametrizacao_equipe.microarea_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($infraestrutrua_id, fn ($q, $id) => $q->where('atencao_basica_parametrizacao_equipe.infraestrutura_id', $id))
            ->get();
    }

    public static function getOcupacoes()
    {
        if (request()->sala_vacinacao_id) {
            $sala_vacinacao = SalaVacinacao::find(request()->sala_vacinacao_id);
            $infraestrutrua_id = $sala_vacinacao->infraestrutura_id;
        } else {
            $infraestrutrua_id = request()->infraestrutura_id;
        }

        $usuario = Usuario::findOrFail(request()->usuario_id);
        $permissao = OutrosPermissaoOcupacao::where('permissao_id', Permissao::FICHA_DE_VACINACAO)->get();
        $codigos = $permissao->pluck('ocupacao');

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

    public static function getPaciente()
    {
        $paciente = Paciente::find(request()->paciente_id);

        return [
            'prontuario' => $paciente->prontuario,
            'cns' => $paciente->cidadao->cns,
            'cpf' => $paciente->cidadao->cpf,
            'sexo' => $paciente->cidadao->sexo->descricao,
            'nascimento' => Carbon::parse($paciente->cidadao->data_nascimento)->format('d/m/Y'),
        ];
    }

    public static function create()
    {
        return [
            'model' => [
                'usuario_id' => null,
                'unidade_id' => null,
                'infraestrutura_id' => null,
                'ocupacao_id' => null,
                'equipe_id' => null,
                'data' => null,
                'paciente' => null,
                'prontuario' => null,
                'cns' => null,
                'cpf' => null,
                'sexo' => null,
                'nascimento' => null,
                'turno' => null,
                'local' => null,
                'viajante' => false,
                'gestante' => false,
                'puerpera' => false,
                'hanseniase' => false,
                'vacina' => null,
                'estrategia' => null,
                'dose' => null,
                'grupo' => null,
                'lote' => null,
                'fabricante' => null,
                'registro_anterior' => false,
                'aplicado_exterior' => false,
                'data_anterior' => null,
                'items' => [],
                'ultimo_frasco' => false
            ],
            'form' => [
                'unidades' => [],
                'locais' => LocalAtendimento::whereIn('id', [
                    AtendimentoIndividualLocalAtendimento::UBS,
                    AtendimentoIndividualLocalAtendimento::UNIDADE_MOVEL,
                    AtendimentoIndividualLocalAtendimento::RUA,
                    AtendimentoIndividualLocalAtendimento::DOMICILIO,
                    AtendimentoIndividualLocalAtendimento::ESCOLA_CRECHE,
                    AtendimentoIndividualLocalAtendimento::OUTROS,
                    AtendimentoIndividualLocalAtendimento::POLO,
                    AtendimentoIndividualLocalAtendimento::INSTITUICAO,
                    AtendimentoIndividualLocalAtendimento::UNIDADE_PRISIONAL_CONGENERES,
                    AtendimentoIndividualLocalAtendimento::UNIDADE_SOCIOEDUCATIVA
                ])->orderBy('descricao')->get(),
                'ocupacoes' => [],
                'equipes' => [],
                'turnos' => Turno::all(),
                'estrategias' => Estrategia::whereIn('id', [
                    ImunizacaoEstrategia::ROTINA,
                    ImunizacaoEstrategia::ESPECIAL,
                    ImunizacaoEstrategia::BLOQUEIO,
                    ImunizacaoEstrategia::INTENSIFICACAO,
                    ImunizacaoEstrategia::CAMPANHA_INDISCRIMINADA,
                    ImunizacaoEstrategia::CAMPANHA_SELETIVA,
                    ImunizacaoEstrategia::SOROTERAPIA,
                    ImunizacaoEstrategia::PESQUISA
                ])->get(),
                'doses' => Dose::all(),
                'grupos' => GrupoAtendimento::where('ativo', true)->get(),
                'lotes' => [],
                'fabricantes' => []
            ],
            'additionals' => [
                'parametrizacao_descricao_vacina' => Parametrizacao::first()->parametrizacao_descricao_vacina_id,
                'usa_ultimo_frasco' => Parametrizacao::first()->usa_ultimo_frasco,
                'sala_vacinacao' => self::getSalaVacinacaoLogada(),
            ]
        ];
    }

    public static function getLotes()
    {
        return DB::table('imunizacao_entrada_vacina as vacina')
            ->select([
                'vacina.id',
                'vacina.lote'
            ])
            ->where('vacina.vacina_id', request()->vacina_id)
            ->orderBy('vacina.lote')
            ->groupBy('id')
            ->get();
    }

    public static function getFabricantes()
    {
        return DB::table('imunizacao_entrada_vacina as vacina')
            ->join('imunizacao_produtor', 'imunizacao_produtor.id', 'vacina.produtor_id')
            ->select([
                'vacina.produtor_id as id',
                'imunizacao_produtor.nome'
            ])
            ->where('vacina.vacina_id', request()->vacina_id)
            ->orderBy('imunizacao_produtor.nome')
            ->groupBy('id')
            ->get();
    }

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

        $sala_vacinacao = self::getSalaVacinacaoLogada();

        DB::transaction(function() use ($sala_vacinacao) {
            if(request()->id) {
                $ficha = FichaVacinacao::find(request()->id);
            } else {
                $ficha = new FichaVacinacao();
                $ficha->usuario_id = request()->usuario_id;
                $ficha->ocupacao_id = request()->ocupacao_id;
                $ficha->equipe_id = request()->equipe_id;
                $ficha->sala_vacinacao_id = $sala_vacinacao->id;
                $ficha->data_atendimento = request()->data;
                $ficha->save();
            }


            foreach(request()->items as $item) {
                $cns = Paciente::find($item['paciente_id'])->cidadao->cns;
                $usuario = Usuario::find(request()->usuario_id);
                if($cns == $usuario->cidadao->cns) {
                    throw new CnsException();
                }

                self::validateItem($item['vacina_id'], $item['estrategia_id'], $item['dose_id'], $item['fabricante_id']);

                $paciente = new VacinacaoPaciente();
                $paciente->vacinacao_id = $ficha->id;
                $paciente->paciente_id = $item['paciente_id'];
                $paciente->turno_id = $item['turno_id'];
                $paciente->local_atendimento_id = $item['local_id'];
                $paciente->viajante = $item['viajante'];
                $paciente->gestante = $item['gestante'];
                $paciente->puerpera = $item['puerpera'];
                $paciente->hanseniase = $item['hanseniase'];
                $paciente->save();

                $vacina = new PacienteItem();
                $vacina->vacinacao_paciente_id = $paciente->id;
                $vacina->vacina_id = $item['vacina_id'];
                $vacina->estrategia_id = $item['estrategia_id'];
                $vacina->dose_id = $item['dose_id'];
                $vacina->grupo_id = $item['grupo_id'];
                $vacina->entrada_id = $item['entrada_id'];
                $vacina->produtor_id = $item['fabricante_id'];
                $vacina->registro_anterior = $item['registro_anterior'];
                $vacina->aplicado_exterior = $item['aplicado_exterior'];
                $vacina->data = $vacina->registro_anterior ? $item['data'] : null;
                $vacina->save();

                if($item['ultimo_frasco']) {
                    $saida = Saida::create([
                        'tipo_id' => SaidaTipo::APLICACAO,
                        'sala_vacinacao_id' => $ficha->sala_vacinacao_id,
                        'data_saida' => $ficha->data_atendimento
                    ]);

                    SaidaVacina::create([
                        'saida_id' => $saida->id,
                        'entrada_vacina_id' => $vacina->entrada_id,
                        'vacina_id' => $vacina->vacina_id,
                        'quantidade' => 1
                    ]);
                }
            }
        });
    }

    private static function destroyRegistroAplicacao($id)
    {
        $sala_vacinacao_logada = self::getSalaVacinacaoLogada();

        if($sala_vacinacao_logada->cria_ficha_ab) {
            $registro = RegistroAplicacao::where('ficha_id', $id)->first();
            if($registro) {
                $registro->delete();
            }
            $atualizacao = RegistroAtualizacao::where('ficha_id', $id)->first();
            if($atualizacao) {
                $atualizacao->delete();
            }
        }
    }

    public static function destroy($id)
    {
        $ficha = FichaVacinacao::find($id);

        if(!is_null($ficha->uuid_ficha)) {
            throw new ExportedException;
        }

        $pacientes = VacinacaoPaciente::where('vacinacao_id', $id)->get();

        foreach($pacientes as $paciente) {
            $items = PacienteItem::where('vacinacao_paciente_id', $paciente->id)->get();

            foreach($items as $item) {
                self::destroyRegistroAplicacao($item->id);
                $item->delete();
            }
            $paciente->delete();
        }

        $ficha->delete();
    }

    public static function destroyAll($id)
    {
        $vacinacao = VacinacaoPaciente::find($id);

        $ficha = FichaVacinacao::find($vacinacao->vacinacao_id);

        if(!is_null($ficha->uuid)) {
            throw new ExportedException;
        }

        $items = PacienteItem::where('vacinacao_paciente_id', $id)->get();
        foreach($items as $item) {
            self::destroyRegistroAplicacao($item->id);
            $item->delete();
        }
        $vacinacao->delete();
    }

    public static function destroyOne($id)
    {
        $item = PacienteItem::find($id);

        $vacinacao = VacinacaoPaciente::find($item->vacinacao_paciente_id);

        $ficha = FichaVacinacao::find($vacinacao->vacinacao_id);

        if(!is_null($ficha->uuid)) {
            throw new ExportedException;
        }

        self::destroyRegistroAplicacao($item->id);
        $item->delete();
    }

    private static function validate()
    {
        return request()->validate([
            'usuario_id' => [
                'required',
                'integer',
                Rule::exists(Usuario::class, 'id'),
            ],
            'unidade_id' => [
                'required',
                'integer',
                Rule::exists(Unidade::class, 'id'),
            ],
            'ocupacao_id' => [
                'required',
                'integer',
                Rule::exists(Ocupacao::class, 'id'),
            ],
            'equipe_id' => [
                'required',
                'integer',
                Rule::exists(Equipe::class, 'id'),
            ],
            'items.*.paciente_id' => [
                'required',
                'integer',
                Rule::exists(Paciente::class, 'id')
            ],
            'items.*.turno_id' => [
                'required',
                'integer',
                Rule::exists(Turno::class, 'id')
            ],
            'items.*.local_id' => [
                'required',
                'integer',
                Rule::exists(LocalAtendimento::class, 'id')
            ],
            'items.*.viajante' => [
                'boolean'
            ],
            'items.*.gestante' => [
                'boolean'
            ],
            'items.*.puerpera' => [
                'boolean'
            ],
            'items.*.hanseniase' => [
                'boolean'
            ],
            'items.*.vacina_id' => [
                'required',
                'integer',
                Rule::exists(Vacina::class, 'id')
            ],
            'items.*.dose_id' => [
                'required',
                'integer',
                Rule::exists(Dose::class, 'id')
            ],
            'items.*.grupo_id' => [
                'nullable',
                Rule::requiredIf(request()->estrategia_id == EnumEstrategia::CAMPANHA_INDISCRIMINADA || request()->estrategia_id == EnumEstrategia::CAMPANHA_SELETIVA),
                'integer',
                Rule::exists(GrupoAtendimento::class ,'id')
            ],
            'items.*.entrada_id' => [
                'required',
                'integer',
                Rule::exists(EntradaVacina::class ,'id')
            ],
            'items.*.fabricante_id' => [
                'required',
                'integer',
                Rule::exists(Produtor::class, 'id')
            ],
            'items.*.registro_anterior' => [
                'boolean'
            ],
            'items.*.aplicado_exterior' => [
                'boolean'
            ],
            'items.*.data' => [
                'date',
                'nullable'
            ]
        ]);
    }

    public static function edit($id)
    {
        $ficha = FichaVacinacao::find($id);

        $vacinacoes = VacinacaoPaciente::has('paciente')->where('vacinacao_id', $id)->get()->map(function($vacinacao) {
            return [
                'id' => $vacinacao->id,
                'prontuario'=> $vacinacao->paciente->prontuario,
                'paciente' => $vacinacao->paciente->cidadao->nome,
                'paciente_id' => $vacinacao->paciente->id,
                'cns' => $vacinacao->paciente->cidadao->cns,
                'cpf' => $vacinacao->paciente->cidadao->cpf,
                'nascimento' => $vacinacao->paciente->cidadao->data_nascimento,
                'sexo' => $vacinacao->paciente->cidadao->sexo->descricao,
                'turno' => $vacinacao->turno_id,
                'turno_nome' => $vacinacao->turno->nome,
                'local' => $vacinacao->local_atendimento_id,
                'viajante' => $vacinacao->viajante,
                'gestante'=> $vacinacao->gestante,
                'puerpera' => $vacinacao->puerpera,
                'hanseniase' => $vacinacao->hanseniase,
            ];
        });

        return [
            'model' => [
                'id' => $ficha->id,
                'usuario' => $ficha->usuario->cidadao->nome,
                'unidade' => $ficha->equipe->unidade->nome_fantasia,
                'ocupacao' => $ficha->ocupacao->nome,
                'equipe' => "INE: " . ($ficha->equipe->area->numero_ine ?? '') .
                    (isset($ficha->equipe->area->descricao) && $ficha->equipe->area->descricao !== '' ? " - Área: " . $ficha->equipe->area->descricao : '') .
                    (isset($ficha->equipe->microarea->descricao) && $ficha->equipe->microarea->descricao !== '' ? " - Microárea: " . $ficha->equipe->microarea->descricao : ''),
                'data' => $ficha->data_atendimento,
                'items' => [],
                'paciente' => null,
                'prontuario' => null,
                'cns' => null,
                'cpf' => null,
                'sexo' => null,
                'nascimento' => null,
                'vacina' => null,
                'turno' => null,
                'local' => null,
                'viajante' => false,
                'gestante' => false,
                'puerpera' => false,
                'hanseniase' => false,
                'estrategia' => null,
                'dose' => null,
                'grupo' => null,
                'lote' => null,
                'fabricante' => null,
                'registro_anterior' => false,
                'aplicado_exterior' => false,
                'data_anterior' => null,
                'ultimo_frasco' => false,
                'exportado' => !is_null($ficha->uuid_ficha)
            ],
            'form' => [
                'turnos' => Turno::all(),
                'estrategias' => Estrategia::whereIn('id', [
                    ImunizacaoEstrategia::ROTINA,
                    ImunizacaoEstrategia::ESPECIAL,
                    ImunizacaoEstrategia::BLOQUEIO,
                    ImunizacaoEstrategia::INTENSIFICACAO,
                    ImunizacaoEstrategia::CAMPANHA_INDISCRIMINADA,
                    ImunizacaoEstrategia::CAMPANHA_SELETIVA,
                    ImunizacaoEstrategia::SOROTERAPIA,
                    ImunizacaoEstrategia::PESQUISA
                ])->get(),
                'doses' => Dose::all(),
                'grupos' => GrupoAtendimento::where('ativo', true)->get(),
                'lotes' => [],
                'fabricantes' => [],
                'locais' => LocalAtendimento::whereIn('id', [
                    AtendimentoIndividualLocalAtendimento::UBS,
                    AtendimentoIndividualLocalAtendimento::UNIDADE_MOVEL,
                    AtendimentoIndividualLocalAtendimento::RUA,
                    AtendimentoIndividualLocalAtendimento::DOMICILIO,
                    AtendimentoIndividualLocalAtendimento::ESCOLA_CRECHE,
                    AtendimentoIndividualLocalAtendimento::OUTROS,
                    AtendimentoIndividualLocalAtendimento::POLO,
                    AtendimentoIndividualLocalAtendimento::INSTITUICAO,
                    AtendimentoIndividualLocalAtendimento::UNIDADE_PRISIONAL_CONGENERES,
                    AtendimentoIndividualLocalAtendimento::UNIDADE_SOCIOEDUCATIVA
                ])->orderBy('descricao')->get(),
            ],
            'items' => $vacinacoes,
            'additionals' => [
                'parametrizacao_descricao_vacina' => Parametrizacao::first()->parametrizacao_descricao_vacina_id,
                'usa_ultimo_frasco' => Parametrizacao::first()->usa_ultimo_frasco,
                'sala_vacinacao' => self::getSalaVacinacaoLogada(),
            ],
        ];
    }

    public static function getVacinas()
    {
        return [
            'items' => PacienteItem::where('vacinacao_paciente_id', request()->id)->get()->map(function($vacina) {
                return [
                    'id' => $vacina->id,
                    'turno' => $vacina->vacinacaoPaciente->turno_id,
                    'local' => $vacina->vacinacaoPaciente->local_atendimento_id,
                    'vacina_id' => $vacina->vacina_id,
                    'vacina' => $vacina->vacina->nome,
                    'estrategia_id' => $vacina->estrategia_id,
                    'estrategia' => $vacina->estrategia->nome ?? '-',
                    'dose_id' => $vacina->dose_id,
                    'dose' => $vacina->dose->nome,
                    'grupo_id' => $vacina->grupo_id,
                    'lote_id' => $vacina->entrada_id,
                    'lote' => $vacina->entrada->lote ?? '-',
                    'fabricante_id' => $vacina->produtor_id,
                    'fabricante' => $vacina->produtor->nome ?? '-',
                    'registro_anterior' => $vacina->registro_anterior,
                    'aplicado_exterior' => $vacina->aplicado_exterior,
                    'data' => $vacina->data,
                    'save' => false
                ];
            })
        ];
    }

    public static function update($id, $request)
    {
        $sala_vacinacao_logada = self::getSalaVacinacaoLogada();

        DB::transaction(function() use($id, $request, $sala_vacinacao_logada) {
            foreach($request->all() as $item) {
                self::validateItem($item['vacina_id'], $item['estrategia_id'], $item['dose_id'], $item['fabricante_id']);

                $update = PacienteItem::find($item['id']);
                if($update) {
                    $update->vacina_id = $item['vacina_id'];
                    $update->estrategia_id = $item['estrategia_id'];
                    $update->dose_id = $item['dose_id'];
                    $update->grupo_id = $item['grupo_id'];
                    $update->entrada_id = $item['entrada_id'];
                    $update->produtor_id = $item['fabricante_id'];
                    $update->registro_anterior = $item['registro_anterior'];
                    $update->data = $update->registro_anterior ? $item['data'] : null;
                    $update->save();

                    $paciente = VacinacaoPaciente::find($update->vacinacao_paciente_id);
                    $paciente->turno_id = $item['turno_id'];
                    $paciente->local_atendimento_id = $item['local_id'];
                    $paciente->viajante = $item['viajante'];
                    $paciente->gestante = $item['gestante'];
                    $paciente->puerpera = $item['puerpera'];
                    $paciente->hanseniase = $item['hanseniase'];
                    $paciente->save();

                    if($sala_vacinacao_logada->cria_ficha_ab) {
                        $registro = RegistroAplicacao::firstWhere('ficha_id', $update->id);
                        if($registro) {
                            if($registro->saida_vacina_id != $update->vacina_id) {
                                $saida = Saida::create([
                                    'tipo_id' => SaidaTipo::APLICACAO,
                                    'sala_vacinacao_id' => $sala_vacinacao_logada->id,
                                    'data_saida' => Carbon::now()->format('Y-m-d'),
                                ]);

                                $saidaVacina = SaidaVacina::create([
                                    'saida_id' => $saida->id,
                                    'entrada_vacina_id' => $item['entrada_id'],
                                    'vacina_id' => $item['vacina_id'],
                                    'quantidade' => 1,
                                ]);
                                $registro->saida_vacina_id = $saidaVacina->id;
                            }
                            $registro->grupo_atendimento_id = $item['grupo_id'];
                            $registro->dose_id = $item['dose_id'];
                            $registro->estrategia_id = $item['estrategia_id'];
                            $registro->comunicante_hanseniase = $item['hanseniase'];
                            $registro->gestante = $item['gestante'];
                            $registro->puerpera = $item['puerpera'];
                            $registro->viajante = $item['viajante'];
                            $registro->save();
                        }
                        $atualizacao = RegistroAtualizacao::firstWhere('ficha_id', $update->id);
                        if($atualizacao) {
                            $atualizacao->vacina_id = $item['vacina_id'];
                            $atualizacao->grupo_atendimento_id = $item['grupo_id'];
                            $atualizacao->dose_id = $item['dose_id'];
                            $atualizacao->estrategia_id = $item['estrategia_id'];
                            $atualizacao->save();
                        }
                    }
                } else {
                    $vacina = new PacienteItem();
                    $vacina->vacinacao_paciente_id = $id;
                    $vacina->vacina_id = $item['vacina_id'];
                    $vacina->estrategia_id = $item['estrategia_id'];
                    $vacina->dose_id = $item['dose_id'];
                    $vacina->grupo_id = $item['grupo_id'];
                    $vacina->entrada_id = $item['entrada_id'];
                    $vacina->produtor_id = $item['fabricante_id'];
                    $vacina->registro_anterior = $item['registro_anterior'];
                    $vacina->data = $vacina->registro_anterior ? $item['data'] : null;
                    $vacina->save();
                }
            }
        });
    }

    private static function getSalaVacinacaoLogada()
    {
        return DB::table('imunizacao_sala_vacinacao')
            ->select([
                'imunizacao_sala_vacinacao.id',
                'imunizacao_sala_vacinacao.cria_ficha_ab'
            ])
            ->join('cadastro_infraestrutura', 'cadastro_infraestrutura.id', 'imunizacao_sala_vacinacao.infraestrutura_id')
            ->where('imunizacao_sala_vacinacao.ativo', true)
            ->where('cadastro_infraestrutura.id', auth()->payload()->get('infraestrutura_id'))
            ->first();
    }

    private static function validateItem($vacina_id, $estrategia_id, $dose_id, $produtor_id)
    {
        $vacina = Vacina::find($vacina_id);
        $regras = VacinacaoRegra::where('codigo', $vacina->codigo)->get();

        if(!$regras) {
            return;
        }

        $estrategia = Estrategia::find($estrategia_id);

        $estrategias = $regras->map(function($regra) {
            return $regra->estrategia;
        })->toArray();

        if(in_array($estrategia->codigo_rnds, $estrategias)) {
            $doses = $regras->filter(function($regra) use($estrategia) {
                return $regra->estrategia == $estrategia->codigo_rnds;
            })->map(function($regra) {
                return $regra->dose;
            })->toArray();

            $dose = Dose::find($dose_id);

            if(!in_array($dose->codigo_esus, $doses)) {
                throw new DoseException();
            }
        } else {
            throw new EstrategiaException();
        }

        $produtor = Produtor::find($produtor_id);

        $vacina = Vacina::find($vacina_id);

        switch($vacina->codigo) {
            case VacinaCodigo::COVID_19_PFIZER_COMIRNATYBIVALENTE:
                if($produtor->nome != EnumProdutor::OXFORD_ASTRAZENECA) {
                    throw new ProdutorException();
                }
                break;
            case VacinaCodigo::COVID_19_SINOVAC_BUTANTAN:
                if($produtor->nome != EnumProdutor::SINOVAC_BUTANTAN) {
                    throw new ProdutorException();
                }
                break;
            case VacinaCodigo::COVID_19_PFIZER:
                if($produtor->nome != EnumProdutor::PFIZER_BIONTECH) {
                    throw new ProdutorException();
                }
                break;
            case VacinaCodigo::COVID_19_JANSSEN:
                if($produtor->nome != EnumProdutor::JANSSEN_CILAG) {
                    throw new ProdutorException();
                }
                break;
            case VacinaCodigo::COVID_19_ASTRAZENECA:
                if($produtor->nome != EnumProdutor::ASTRAZENECA_CHADOX1_S) {
                    throw new ProdutorException();
                }
                break;
            case VacinaCodigo::VVBN:
                if($produtor->nome != EnumProdutor::GAMALEYA_SPUTNIK_V) {
                    throw new ProdutorException();
                }
                break;
            case VacinaCodigo::COVID_19_BHARAT:
                if($produtor->nome != EnumProdutor::BHARAT_COVAXIN) {
                    throw new ProdutorException();
                }
                break;
            case VacinaCodigo::COVID_19_MODERNA_SPIKEVAX:
                if($produtor->nome != EnumProdutor::MODERNA) {
                    throw new ProdutorException();
                }
                break;
            case VacinaCodigo::COVID_19_SINOVAC_CORONAVAC:
                if($produtor->nome != EnumProdutor::SINOVAC_CORONAVAC) {
                    throw new ProdutorException();
                }
                break;
            case VacinaCodigo::COVID_19_PFIZER_COMIRNATY_PEDIATRICA:
            case VacinaCodigo::COVID_19_PFIZER_COMIRNATY_PEDIATRICA_MENOR_DE_5_ANOS:
            case VacinaCodigo::COVID_19_PFIZER_COMIRNATYBIVALENTE:
                if($produtor->nome != EnumProdutor::COMIRNATY_PFIZER_BIONTECH) {
                    throw new ProdutorException();
                }
                break;
        }
    }

    public static function getEstrategias()
    {
        if (request()->origem && request()->origem === 'atualizacao') {
            return Estrategia::all();
        } else {
            if(request()->registro_anterior) {
                return Estrategia::where('codigo_rnds', EnumEstrategia::PESQUISA)->get();
            }

            $vacina = Vacina::find(request()->vacina_id);

            $regras = VacinacaoRegra::where('codigo', $vacina->codigo)
                ->when((isset(request()->origem) && request()->origem === 'aplicacao'), fn ($q) => $q->where('exibe_aplicacao', true))
                ->when((isset(request()->origem) && request()->origem === 'aprazamento'), fn ($q) => $q->where('exibe_aprazamento', true))
                ->groupBy('estrategia')
                ->get();

            if($regras->isEmpty()) {
                return Estrategia::all();
            }

            return Estrategia::whereIn('codigo_rnds', $regras->pluck('estrategia'))->get();
        }
    }

    public static function getDoses()
    {
        if(!request()->estrategia_id) {
            return Dose::all();
        }

        $vacina = Vacina::find(request()->vacina_id);
        $estrategia = Estrategia::find(request()->estrategia_id);

        $regras = VacinacaoRegra::where('codigo', $vacina->codigo)
            ->where('estrategia', $estrategia->codigo_rnds)
            ->when((isset(request()->origem) && request()->origem === 'aplicacao'), fn ($q) => $q->where('exibe_aplicacao', true))
            ->when((isset(request()->origem) && request()->origem === 'atualizacao'), fn ($q) => $q->where('exibe_atualizacao', true))
            ->when((isset(request()->origem) && request()->origem === 'aprazamento'), fn ($q) => $q->where('exibe_aprazamento', true))
            ->get();

        if($regras->isEmpty()) {
            return Dose::all();
        }

        return Dose::whereIn('id', $regras->pluck('dose'))->get();
    }
}