<?php

namespace App\Http\Controllers\Parametrizacao;

use App\Enums\Cadastro\Grupo\GrupoTipo;
use App\Enums\ExameLaboratorial\TipoFator;
use App\Enums\Geral\MedidaTempo;
use App\Enums\Parametrizacao\Exame\Classificacao;
use App\Enums\Parametrizacao\Exame\Tipo;
use App\Enums\Sigtap\Complexidade;
use App\Enums\Sigtap\Registro;
use App\Exceptions\Model\DeletingModelException;
use App\Http\Controllers\Controller;
use App\Http\Requests\Parametrizacao\ExameRequest;
use App\Models\Cadastro\Grupo\Grupo;
use App\Models\Cadastro\SujeitoAtencao\Lotacao;
use App\Models\Cadastro\SujeitoAtencao\Paciente;
use App\Models\Cadastro\SujeitoAtencao\Sexo;
use App\Models\ExameImagem\Agendamento\Agendamento;
use App\Models\ExameImagem\Agendamento\AgendamentoExame;
use App\Models\ExameLaboratorial\FormulaExame\FormulaExame;
use App\Models\ExameLaboratorial\FormulaExame\FormulaExameFator;
use App\Models\Parametrizacao\Exame\Exame;
use App\Models\Parametrizacao\Exame\ExameComposicao;
use App\Models\Parametrizacao\Exame\ExameComposicaoCasaDecimal;
use App\Models\Parametrizacao\Exame\ExameComposicaoLista;
use App\Models\Parametrizacao\Exame\ExameComposicaoSituacao;
use App\Models\Parametrizacao\Exame\ExameComposicaoTipoResultado;
use App\Models\Parametrizacao\Exame\ExameComposicaoUnidade;
use App\Models\Parametrizacao\Exame\ExameComposicaoVariavel;
use App\Models\Parametrizacao\Exame\ExameTextoPronto;
use App\Models\Parametrizacao\Exame\ExameTipo;
use App\Models\Regulacao\Tipo as RegulacaoTipo;
use App\Models\Sigtap\Procedimento;
use App\Utils\DataUtil;
use Exception;
use Illuminate\Http\Response;
use Illuminate\Support\Facades\DB;

class ExameController extends Controller
{
    protected $modulo = 'parametrizacao';
    protected $funcionalidade = 'exame';

    public function autocomplete()
    {

        if (request()->get('exame_grupo')) {

            $grupos = DB::table('cadastro_grupo')
                ->select([
                    'id',
                    DB::raw('"" AS codigo'),
                    'nome',
                    DB::raw('true AS pertence_grupo'),
                ]);

            $exames = DB::table('parametrizacao_exame')
                ->select([
                    'id',
                    'codigo',
                    'nome',
                    DB::raw('false AS pertence_grupo'),
                ]);

            if (is_numeric(request()->get('tipo_id'))) {

                $exames->where('parametrizacao_exame.tipo_id', request()->get('tipo_id'));
            }

            $exames->union($grupos);
        } else {

            $exames = DB::table('parametrizacao_exame')
                ->leftJoin('sigtap.procedimento', function ($join) {

                    $join->on('sigtap.procedimento.codigo', 'parametrizacao_exame.codigo')
                        ->where('sigtap.procedimento.competencia_id', '=', function ($query) {

                            $query->select('sigtap.competencia.id')
                                ->from('sigtap.competencia')
                                ->orderByDesc('sigtap.competencia.valor')
                                ->limit(1);
                        });
                })
                ->leftJoin(
                    'parametrizacao_procedimento',
                    'parametrizacao_procedimento.procedimento_codigo',
                    'parametrizacao_exame.codigo'
                )
                ->select(
                    'parametrizacao_exame.id',
                    'parametrizacao_exame.tipo_id',
                    'parametrizacao_exame.grupo_tipo_id',
                    'parametrizacao_exame.codigo',
                    'parametrizacao_exame.nome',
                    'parametrizacao_exame.sigla_exame',
                    'parametrizacao_exame.ativo',
                    'parametrizacao_exame.observacao',
                    'parametrizacao_exame.sexo_id',
                    'parametrizacao_procedimento.apelido',
                    'sigtap.procedimento.nome as procedimento_nome',
                    'sigtap.procedimento.id as procedimento_id',
                    'sigtap.procedimento.quantidade_maxima_execucao',
                    'parametrizacao_exame.valor',
                    'parametrizacao_exame.valor_sigtap',
                    'parametrizacao_exame.exigir_peso_altura_circunferencia',
                    'parametrizacao_exame.validade',
                    'parametrizacao_exame.quantidade_maxima',
                    'parametrizacao_exame.prazo_entrega',
                    'parametrizacao_exame.provisorio',
                    'parametrizacao_exame.outro_municipio',
                    'parametrizacao_exame.quantidade_reagente',
                    'parametrizacao_exame.permite_repeticao',
                    'parametrizacao_exame.senha_supervisor',
                    'sigtap.procedimento.valor_servico_ambilatorial',
                    'sigtap.procedimento.sexo',
                    'sigtap.procedimento.complexidade',
                )
                ->whereNull('parametrizacao_exame.deleted_at');

            if (request()->get('filtrar_ativos')) {

                $exames->where('parametrizacao_exame.ativo', true);
            }

            if (is_numeric(request()->get('tipo_id'))) {

                $exames->where('parametrizacao_exame.tipo_id', request()->get('tipo_id'));
            }

            if (request()->get('parametrizacao_exame_laboratorial_infraestrutura_id')) {

                $exames->where(fn ($q) => $q
                    ->where('parametrizacao_exame.tipo_id', '<>', Tipo::LABORATORIAL)
                    ->orWhere(fn ($q) => $q
                        ->where('parametrizacao_exame.tipo_id', Tipo::LABORATORIAL)
                        ->where(fn ($q) => $q
                            ->whereExists(fn ($q) => $q
                                ->selectRaw(1)
                                ->from('exame_laboratorial_parametrizacao_unidade_solicitante_exame_item')
                                ->join(
                                    'exame_laboratorial_parametrizacao_unidade_solicitante_exame',
                                    'exame_laboratorial_parametrizacao_unidade_solicitante_exame.id',
                                    'exame_laboratorial_parametrizacao_unidade_solicitante_exame_item.unidade_solicitante_exame_id'
                                )
                                ->whereColumn(
                                    'exame_laboratorial_parametrizacao_unidade_solicitante_exame_item.exame_id',
                                    'parametrizacao_exame.id'
                                )
                                ->where(
                                    'exame_laboratorial_parametrizacao_unidade_solicitante_exame.infraestrutura_id',
                                    request()->get('parametrizacao_exame_laboratorial_infraestrutura_id')
                                )
                            )
                            ->orWhereNotExists(fn ($q) => $q
                                ->selectRaw(1)
                                ->from('exame_laboratorial_parametrizacao_unidade_solicitante_exame')
                                ->where(
                                    'exame_laboratorial_parametrizacao_unidade_solicitante_exame.infraestrutura_id',
                                    request()->get('parametrizacao_exame_laboratorial_infraestrutura_id')
                                )
                            )
                        )
                    )
                );
            }

            if (request()->get('classificacao_id') == Classificacao::PROVISORIO) {

                $exames->where('parametrizacao_exame.provisorio', true);
            }

            if (request()->get('classificacao_id') == Classificacao::OUTRO_MUNICIPIO) {

                $exames->where('parametrizacao_exame.outro_municipio', true);
            }

            if (is_numeric(request()->get('grupo_id'))) {

                $exames->where('parametrizacao_exame.grupo_tipo_id', request()->get('grupo_id'));
            }

            if (request()->get('sexo_id')) {

                $exames->where(function ($query) {

                    $query
                        ->where(function ($query) {

                            $query->where('parametrizacao_exame.exige_procedimento', true)
                                ->where(function ($query) {

                                    $query->where('sigtap.procedimento.sexo', Sexo::find(request()->get('sexo_id'))->identificador)
                                        ->orWhere('sigtap.procedimento.sexo', 'I')
                                        ->orWhere('sigtap.procedimento.sexo', 'N');
                                });
                        })
                        ->orWhere(function ($query) {

                            $query->where('parametrizacao_exame.exige_procedimento', false)
                                ->where('parametrizacao_exame.sexo_id', request()->get('sexo_id'));
                        });
                });
            }

            if (is_numeric(request()->get('paciente_id'))) {

                $paciente = Paciente::findOrFail(request()->get('paciente_id'));

                $exames->where(function ($exames) use ($paciente) {

                    $exames
                        ->where(function ($exames) use ($paciente) {
                            $exames->where('parametrizacao_exame.exige_procedimento', false)
                                ->where(function ($exames) use ($paciente) {
                                    $exames->whereNull('parametrizacao_exame.sexo_id')
                                        ->orWhere('parametrizacao_exame.sexo_id', $paciente->cidadao->sexo_id);
                                });
                        })
                        ->orWhere(function ($exames) use ($paciente) {

                            $exames->where('parametrizacao_exame.exige_procedimento', true)
                                ->where(function ($exames) use ($paciente) {

                                    $exames->where(function ($exames) use ($paciente) {
                                        $exames
                                            ->where('sigtap.procedimento.sexo', $paciente->cidadao->sexo->identificador)
                                            ->orWhere('sigtap.procedimento.sexo', 'I')
                                            ->orWhere('sigtap.procedimento.sexo', 'N');
                                    });

                                    if (!$paciente->is_desconhecido) {

                                        $exames->where(function ($exames) use ($paciente) {

                                            $meses = $paciente->cidadao->idade['anos'] * 12;

                                            $exames
                                                ->where(function ($query) use ($meses) {

                                                    $query->where('sigtap.procedimento.idade_minima', '<=', $meses)
                                                        ->orWhere('sigtap.procedimento.idade_minima', 9999);
                                                })
                                                ->where(function ($query) use ($meses) {

                                                    $query->where('sigtap.procedimento.idade_maxima', '>=', $meses)
                                                        ->orWhere('sigtap.procedimento.idade_maxima', 9999);
                                                });
                                        });
                                    }
                                });
                        });
                });
            }

            $cbo = !is_null(request()->get('cbo')) ? request()->get('cbo') : null;

            if (is_null($cbo) && DataUtil::isStringTrue(request()->query('cbo_lotacao_atual'))) {

                $cbo = Lotacao::findOrFail(auth()->payload()->get('lotacao_id'))->ocupacao->codigo;
            }

            if (!is_null($cbo)) {

                $exames->where(function ($exames) use ($cbo) {

                    $onlyWithCbo = DataUtil::isStringBoolean(request()->get('only_with_cbo'))
                        ? DataUtil::getBooleanValueFromStringBoolean(request()->get('only_with_cbo'))
                        : false;

                    $onlyFilterExameImagemCbo = DataUtil::isStringBoolean(request()->get('only_filter_exame_imagem_cbo'))
                        ? DataUtil::getBooleanValueFromStringBoolean(request()->get('only_filter_exame_imagem_cbo'))
                        : false;

                    $exames->whereExists(function($query) use ($cbo) {

                        $query->select(DB::raw(1))
                            ->from('sigtap.procedimento_ocupacao')
                            ->whereColumn('sigtap.procedimento_ocupacao.procedimento_id', 'sigtap.procedimento.id')
                            ->join('sigtap.ocupacao', 'sigtap.ocupacao.id', 'sigtap.procedimento_ocupacao.ocupacao_id');

                        if (is_array($cbo)) {

                            $query->whereIn('sigtap.ocupacao.codigo', $cbo);
                        } else {

                            $query->where('sigtap.ocupacao.codigo', $cbo);
                        }
                    });

                    if (!$onlyWithCbo) {

                        $exames->orWhereNotExists(function ($query) {

                            $query->select(DB::raw(1))
                                ->from('sigtap.procedimento_ocupacao')
                                ->whereColumn('sigtap.procedimento_ocupacao.procedimento_id', 'sigtap.procedimento.id');
                        });
                    }

                    if ($onlyFilterExameImagemCbo) {

                        $exames->orWhere('parametrizacao_exame.tipo_id', '<>', Tipo::IMAGEM);
                    }
                });
            }

            if (DataUtil::isStringTrue(request()->query('atencao_basica_cadastro_exame_solicitado_avaliado'))) {

                $exames->whereNotExists(function($query) {

                    $query->select(DB::raw(1))
                        ->from('atencao_basica_cadastro_exame_solicitado_avaliado')
                        ->whereColumn('sigtap.procedimento.codigo', 'atencao_basica_cadastro_exame_solicitado_avaliado.codigo_procedimento');
                });
            }

            if (DataUtil::isStringTrue(request()->query('atencao_basica_cadastro_triagem_neonatal'))) {

                $exames->whereNotExists(function($query) {

                    $query->select(DB::raw(1))
                        ->from('atencao_basica_cadastro_triagem_neonatal')
                        ->whereColumn('sigtap.procedimento.codigo', 'atencao_basica_cadastro_triagem_neonatal.codigo_procedimento');
                });
            }

            if (DataUtil::isStringBoolean(request()->get('alto_custo'))) {

                $exames->where(function ($query) {

                    if (DataUtil::isStringTrue(request()->get('alto_custo'))) {

                        $query->whereIn('sigtap.procedimento.complexidade', [
                                Complexidade::MEDIA_COMPLEXIDADE,
                                Complexidade::ALTA_COMPLEXIDADE,
                            ])
                            ->whereExists(function ($query) {

                                $query->select(DB::raw(1))
                                    ->from('sigtap.procedimento_registro')
                                    ->join(
                                        'sigtap.registro',
                                        'sigtap.registro.id',
                                        'sigtap.procedimento_registro.registro_id'
                                    )
                                    ->whereColumn('sigtap.procedimento_registro.procedimento_id', 'sigtap.procedimento.id')
                                    ->whereIn('sigtap.registro.codigo', [
                                        Registro::APAC_PROC_PRINCIPAL,
                                        Registro::APAC_PROC_SECUNDARIO,
                                    ]);
                            });
                    }
                    else {

                        $query->whereNotIn('sigtap.procedimento.complexidade', [
                            Complexidade::MEDIA_COMPLEXIDADE,
                            Complexidade::ALTA_COMPLEXIDADE,
                        ]);
                    }
                });
            }

            if (DataUtil::isStringBoolean(request()->get('with_unidade_solicitante')) && filter_var(request()->get('with_unidade_solicitante'), FILTER_VALIDATE_BOOLEAN)) {

                $exames->where(function ($query) {

                    $query->whereExists(function ($query) {

                            $query->select(DB::raw(1))
                                ->from('exame_laboratorial_parametrizacao_unidade_solicitante_exame_item')
                                ->join(
                                    'exame_laboratorial_parametrizacao_unidade_solicitante_exame',
                                    'exame_laboratorial_parametrizacao_unidade_solicitante_exame.id',
                                    'exame_laboratorial_parametrizacao_unidade_solicitante_exame_item.unidade_solicitante_exame_id'
                                )
                                ->whereColumn('exame_laboratorial_parametrizacao_unidade_solicitante_exame_item.exame_id', 'parametrizacao_exame.id')
                                ->where('exame_laboratorial_parametrizacao_unidade_solicitante_exame.infraestrutura_id', request()->infraestrutura_id);
                        });
                });
            }

            if (DataUtil::isStringBoolean(request()->get('without_exame_regulado')) && filter_var(request()->get('without_exame_regulado'), FILTER_VALIDATE_BOOLEAN)) {

                $exames->whereNull('regulacao_tipo_id');
            }
        }

        return datatables()->of($exames)->skipTotalRecords()->make(true);
    }

    public function datatable()
    {
        $exames = DB::table('parametrizacao_exame')
            ->leftJoin('parametrizacao_exame_tipo', 'parametrizacao_exame_tipo.id', 'parametrizacao_exame.tipo_id')
            ->leftJoin('cadastro_grupo', 'cadastro_grupo.id', 'parametrizacao_exame.grupo_tipo_id')
            ->leftJoin('sigtap.procedimento', function ($join) {

                $join->on('sigtap.procedimento.codigo', 'parametrizacao_exame.codigo')
                    ->where('sigtap.procedimento.competencia_id', '=', function ($query) {

                        $query->select('sigtap.competencia.id')
                            ->from('sigtap.competencia')
                            ->orderByDesc('sigtap.competencia.valor')
                            ->limit(1);
                    });
            })
            ->select(
                'parametrizacao_exame.id',
                'parametrizacao_exame.nome AS exame',
                'parametrizacao_exame_tipo.nome AS tipo',
                DB::raw(
                    "CASE WHEN cadastro_grupo.nome IS NULL
                    THEN '-'
                    ELSE cadastro_grupo.nome END AS grupo"
                ),
                'procedimento.codigo as procedimentoCodigo',
                'procedimento.nome AS procedimentoNome'
            )
            ->whereNull('parametrizacao_exame.deleted_at');

        return datatables()->of($exames)->make(true);
    }

    public function index()
    {
        $this->auth(__FUNCTION__);

        $response = null;

        if (request()->has('listar') && request()->listar === 'grupos') {
            $response = [
                'grupos' => $this->getGrupos(),
                'tipos' => RegulacaoTipo::orderBy('nome')->get(['id', 'nome']),
            ];
        } else {
            $response = $this->get(Exame::class)->orderBy('nome')->get();
        }

        return response()->json($response, Response::HTTP_OK);
    }

    public function create()
    {
        $this->auth(__FUNCTION__);

        $exame = new Exame;
        $exame->fill(array_fill_keys($exame->getFillable(), null));

        return response()->json(
            [
                'form' => $this->getFormData(),
                'model' =>  [
                    'tipo_id' => null,
                    'grupo_tipo_id' => null,
                    'tipo_salvo_id' => null,
                    'sigla_exame' => null,
                    'nome' => null,
                    'ativo' => true,
                    'exige_procedimento' => true,
                    'observacao' => null,
                    'sexoId' => null,
                    'is_regulado' => false,
                    'regulacao_tipo_id' => null,
                    'is_ppi' => false,
                    'valor_ppi' => null,
                    'tempo_medio_previsto_atendimento_dias' => null,
                    'laboratorio' => [
                        'prazo_entrega' => null,
                        'validade' => null,
                        'valor' => null,
                        'quantidade_maxima' => null,
                        'outro_municipio' => false,
                        'provisorio' => false,
                        'sigilo' => false,
                        'senha_supervisor' => false,
                        'ultimo_resultado' => null,
                        'mapa_agrupado' => false,
                        'posicao_mapa' => null,
                        'valor_sigtap' => false,
                        'quantidade_reagente' => null,
                        'permite_repeticao' => false,
                    ],
                    'imagem' => [
                        'prazo_entrega' => null,
                        'validade' => null,
                        'valor' => null,
                        'valor_sigtap' => null,
                        'quantidade_maxima' => null,
                        'outro_municipio' => false,
                        'provisorio' => false,
                        'senha_supervisor' => false,
                        'ultimo_resultado' => null,
                        'resultado'  => null,
                        'valor_sigtap' => false,
                        'exigir_peso_altura_circunferencia' => false,
                    ],
                    'composicao' => [],
                    'texto_pronto' => [],
                ]
            ],
            Response::HTTP_OK
        );
    }

    public function store(ExameRequest $request)
    {
        if ($request->has('action') && $request->action === 'atribuicao-parametro-grupo') {
            $params = [];

            if (isset($request->regulacao_tipo_id)) {
                $params['regulacao_tipo_id'] = $request->regulacao_tipo_id;
            }

            if (!isset($request->regulacao_tipo_id)) {
                $params['regulacao_tipo_id'] = NULL;
            }
            if (isset($request->exigir_peso_altura_circunferencia)) {
                $params['exigir_peso_altura_circunferencia'] = $request->exigir_peso_altura_circunferencia;
            }

            if (isset($request->is_ppi)) {
                $params['is_ppi'] = $request->is_ppi;
            }

            if (isset($request->tempo_medio_previsto_atendimento_dias)) {
                $params['tempo_medio_previsto_atendimento_dias'] = $request->tempo_medio_previsto_atendimento_dias;
            }

            foreach ($request->grupos as $grupo) {
                Exame::where('grupo_tipo_id', $grupo)->update($params);
            }

            return response()->json([], Response::HTTP_CREATED);
        } else {
            $this->auth(__FUNCTION__);

            $exame = Exame::create($this->getParams($request))->fresh();

            DB::transaction(function () use ($request, $exame) {

                foreach ($request['composicao'] as $param) {

                    $composicao = new ExameComposicao();

                    $composicao->exame_id = $exame->id;
                    $composicao->descricao = $param['descricao'];
                    $composicao->limite_inferior = $param['limite_inferior'];
                    $composicao->limite_superior = $param['limite_superior'];
                    $composicao->unidade_id = $param['unidade_id'];
                    $composicao->referencia = $param['referencia'];
                    $composicao->tipo_idade_id = $param['tipo_idade_id'];
                    $composicao->idade_inicial = $param['idade_inicial'];
                    $composicao->idade_final = $param['idade_final'];
                    $composicao->sexo_id = $param['sexo_id'];
                    $composicao->tipo_resultado_id = $param['tipo_resultado_id'];
                    $composicao->casa_decimal_id = $param['casa_decimal_id'];
                    $composicao->formula_id = $param['formula_id'];
                    $composicao->visivel = $param['visivel'];
                    $composicao->referencia_especial = $param['referencia_especial'];
                    $composicao->valor_absoluto = $param['valor_absoluto'];
                    $composicao->resultado = $param['resultado'];

                    if (!is_null($param['limite_inferior'])) {
                        $composicao->limite_inferior = str_replace('.', '', $composicao->limite_inferior);
                        $composicao->limite_inferior = str_replace(',', '.', $composicao->limite_inferior);
                    }

                    if (!is_null($param['limite_superior'])) {
                        $composicao->limite_superior = str_replace('.', '', $composicao->limite_superior);
                        $composicao->limite_superior = str_replace(',', '.', $composicao->limite_superior);
                    }

                    $composicao->save();

                    foreach ($param['lista'] ?? [] as $paramLista) {

                        $lista = new ExameComposicaoLista();

                        $lista->composicao_id = $composicao->id;
                        $lista->descricao = $paramLista['descricao'];
                        $lista->ordem = $paramLista['ordem'];
                        $lista->situacao_id = $paramLista['situacao_id'];
                        $lista->padrao = $paramLista['padrao'];
                        $lista->save();
                    }

                    foreach ($param['variavel'] ?? [] as $paramVariavel) {

                        $variavel = new ExameComposicaoVariavel();

                        $variavel->composicao_id = $composicao->id;
                        $variavel->fator_id = $paramVariavel['fator_id'];
                        $variavel->ordem = $paramVariavel['ordem'];
                        $variavel->save();
                    }
                }

                foreach ($request['texto_pronto'] ?? [] as $param) {

                    $texto = new ExameTextoPronto();

                    $texto->exame_id = $exame->id;
                    $texto->codigo = $param['codigo'];
                    $texto->descricao = $param['descricao'];
                    $texto->save();
                }
            });

            return response()->json($exame, Response::HTTP_CREATED);
        }
    }

    public function show($id)
    {
        $this->auth(__FUNCTION__);

        return response()->json($this->get(Exame::class, $id), Response::HTTP_OK);
    }

    public function edit($id)
    {
        $this->auth(__FUNCTION__);

        $exame = Exame::findOrFail($id);

        $valor = number_format($exame->valor, 2, ",", ".");

        return response()->json(
            [
                'form' => $this->getFormData(),
                'model' =>  [
                    'tipo_id' => $exame->tipo_id ?? null,
                    'tipo_salvo_id' => $exame->tipo_id ?? null,
                    'grupo_tipo_id' => $exame->grupo_tipo_id ?? null,
                    'grupo_tipo_nome' => $exame->grupo_tipo_id->nome ?? null,
                    'grupo_salvo' => $exame->grupo_tipo_id ?? null,
                    'procedimento' => $exame->procedimento ?? null,
                    'sigla_exame' => $exame->sigla_exame ?? null,
                    'sexo_id' => $exame->sexo_id ?? null,
                    'nome' => $exame->nome ?? null,
                    'salva_nome_procedimento' => $exame->procedimento ?? null,
                    'ativo' => $exame->ativo ?? true,
                    'exige_procedimento' => $exame->exige_procedimento ?? true,
                    'observacao' => $exame->observacao ?? null,
                    'is_regulado' => $exame->is_regulado,
                    'regulacao_tipo_id' => $exame->regulacao_tipo_id,
                    'is_ppi' => $exame->is_ppi ?? false,
                    'valor_ppi' => $exame->valor_ppi,
                    'tempo_medio_previsto_atendimento_dias' => $exame->tempo_medio_previsto_atendimento_dias,
                    'laboratorio' => [
                        'prazo_entrega' => $exame->prazo_entrega ?? null,
                        'validade' => $exame->validade ?? null,
                        'valor' => $valor ?? null,
                        'quantidade_maxima' => $exame->quantidade_maxima ?? null,
                        'outro_municipio' => $exame->outro_municipio ?? false,
                        'provisorio' => $exame->provisorio ?? false,
                        'sigilo' => $exame->sigilo ?? false,
                        'senha_supervisor' => $exame->senha_supervisor ?? false,
                        'ultimo_resultado' => $exame->ultimo_resultado ?? null,
                        'mapa_agrupado' => $exame->mapa_agrupado ?? false,
                        'posicao_mapa' => $exame->posicao_mapa ?? null,
                        'valor_sigtap' => $exame->valor_sigtap ?? true,
                        'quantidade_reagente' => $exame->quantidade_reagente ?? null,
                        'permite_repeticao' => $exame->permite_repeticao ?? false,
                    ],
                    'imagem' => [
                        'prazo_entrega' => $exame->prazo_entrega ?? null,
                        'validade' => $exame->validade ?? null,
                        'valor' => $valor ?? null,
                        'quantidade_maxima' => $exame->quantidade_maxima ?? null,
                        'outro_municipio' => $exame->outro_municipio ?? false,
                        'provisorio' => $exame->provisorio ?? false,
                        'senha_supervisor' => $exame->senha_supervisor ?? false,
                        'ultimo_resultado' => $exame->ultimo_resultado ?? null,
                        'resultado'  => $exame->resultado ?? null,
                        'valor_sigtap' => $exame->valor_sigtap ?? true,
                        'exigir_peso_altura_circunferencia' => $exame->exigir_peso_altura_circunferencia ?? false,
                    ],
                    'composicao' => ExameComposicao::where('exame_id', $id)
                        ->get()
                        ->map(fn ($query) => [
                            'id' => $query->id,
                            'exame_id' => $query->exame_id,
                            'descricao' => $query->descricao,
                            'limite_inferior' => number_format($query->limite_inferior, 2, ',', '.'),
                            'limite_superior' => number_format($query->limite_superior, 2, ',', '.'),
                            'unidade_id' => $query->unidade_id,
                            'unidade' => $query->unidade_id ? $query->unidade->descricao : '-',
                            'referencia' => $query->referencia,
                            'tipo_idade_id' => $query->tipo_idade_id,
                            'tipo_idade' => $query->tipoIdade ? mb_strtoupper($query->tipoIdade->nome) : '-',
                            'idade_inicial' => $query->idade_inicial,
                            'idade_final' => $query->idade_final,
                            'sexo_id' => $query->sexo_id,
                            'sexo' => $query->sexo->descricao ?? 'AMBOS',
                            'tipo_resultado_id' => $query->tipo_resultado_id,
                            'tipo_resultado' => $query->tipoResultado->descricao,
                            'casa_decimal_id' => $query->casa_decimal_id,
                            'formula_id' => $query->formula_id,
                            'visivel' => $query->visivel,
                            'valor_absoluto' => $query->valor_absoluto,
                            'resultado' => $query->resultado,
                            'referencia_especial' => $query->referencia_especial,
                            'lista' => ExameComposicaoLista::where('composicao_id', $query->id)
                                ->get()
                                ->map(fn ($composicao) => [
                                    'id' => $composicao->id,
                                    'descricao' => $composicao->descricao,
                                    'ordem' => $composicao->ordem,
                                    'situacao_id' => $composicao->situacao_id,
                                    'situacao' => $composicao->situacao->descricao,
                                    'padrao' => $composicao->padrao,
                                ]),
                            'variavel' => ExameComposicaoVariavel::where('composicao_id', $query->id)
                                ->get()
                                ->map(fn ($variavel) => [
                                    'id' => $variavel->id,
                                    'ordem' => $variavel->ordem,
                                    'fator_id' => $variavel->fator_id ?? null,
                                    'fator' => $variavel->fator->fator ?? null,
                                ]),
                        ]),
                    'texto_pronto' => ExameTextoPronto::where('exame_id', $id)
                        ->get()
                        ->map(fn ($query) => [
                            'id' => $query->id,
                            'exame_id' => $query->exame_id,
                            'codigo' => $query->codigo,
                            'descricao' => $query->descricao,
                        ]),
                ],
            ],
            Response::HTTP_OK
        );
    }

    private function getFormData()
    {
        return [
            'composicao_unidade' => ExameComposicaoUnidade::orderBy('descricao')->get(),
            'composicao_sexo' => Sexo::orderBy('descricao')->get(),
            'composicao_tipo_resultado' => ExameComposicaoTipoResultado::orderBy('descricao')->get(),
            'composicao_tipo_idade' => self::getMedidaTempo(),
            'composicao_casa_decimal' => ExameComposicaoCasaDecimal::orderBy('descricao')->get(),
            'composicao_visivel' => [
                [
                    'value' => true,
                    'text' => 'SIM',
                ],
                [
                    'value' => false,
                    'text' => 'NÃO',
                ]
            ],
            'composicao_situacao' => ExameComposicaoSituacao::orderBy('descricao')->get(),
            'formulas' => FormulaExame::orderBy('nome')->get(),
            'tipos' => ExameTipo::orderBy('nome')->get(),
            'variaveis' => FormulaExameFator::where('tipo', TipoFator::VARIAVEL)
                ->get()
                ->map(function ($query) {
                    return [
                        'id' => $query->id,
                        'fator' => $query->fator,
                    ];
                })->values(),
            'grupos' => Grupo::where('grupo_tipo_id', GrupoTipo::EXAME)->orderBy('nome')
                ->get()
                ->map(fn ($query) => [
                    'id' => $query->id,
                    'nome' => $query->nome,
                    'regulacao_tipo_id' => $query->regulacao_tipo_id,
                ]),
            'sexos' => Sexo::orderBy('descricao')->get()->map(fn ($sexo) => [
                'id' => $sexo->id,
                'descricao' => $sexo->descricao
            ]),
            'regulacao_tipos' => RegulacaoTipo::orderBy('nome')->get(['id', 'nome']),
        ];
    }

    private static function getMedidaTempo()
    {
        return DB::table('geral_medida_tempo')
            ->select(
                'id',
                DB::raw("UPPER(nome) as nome"),
            )
            ->where(function($query) {
                $query->where('id', MedidaTempo::DIAS)
                    ->orWhere('id', MedidaTempo::MESES)
                    ->orWhere('id', MedidaTempo::ANOS);
            })
            ->get();
    }

    public function update(ExameRequest $request, $id)
    {
        $this->auth(__FUNCTION__);

        $exame = tap(Exame::findOrFail($id))->update($this->getParams($request));

        DB::transaction(function () use ($request, $id) {

            $ids = [];

            foreach ($request['composicao'] as $param) {

                if (is_numeric($param['id'])) {

                    $composicao = ExameComposicao::where('id', $param['id'])
                        ->first();
                } else {

                    $composicao = new ExameComposicao();
                }

                $composicao->exame_id = $id;
                $composicao->descricao = $param['descricao'];
                $composicao->limite_inferior = $param['limite_inferior'];
                $composicao->limite_superior = $param['limite_superior'];
                $composicao->unidade_id = $param['unidade_id'];
                $composicao->referencia = $param['referencia'];
                $composicao->tipo_idade_id = $param['tipo_idade_id'];
                $composicao->idade_inicial = $param['idade_inicial'];
                $composicao->idade_final = $param['idade_final'];
                $composicao->sexo_id = $param['sexo_id'];
                $composicao->tipo_resultado_id = $param['tipo_resultado_id'];
                $composicao->casa_decimal_id = $param['casa_decimal_id'];
                $composicao->formula_id = $param['formula_id'];
                $composicao->visivel = $param['visivel'];
                $composicao->referencia_especial = $param['referencia_especial'];
                $composicao->valor_absoluto = $param['valor_absoluto'];
                $composicao->resultado = $param['resultado'];

                if (!is_null($param['limite_inferior'])) {
                    $composicao->limite_inferior = str_replace('.', '', $composicao->limite_inferior);
                    $composicao->limite_inferior = str_replace(',', '.', $composicao->limite_inferior);
                }

                if (!is_null($param['limite_superior'])) {
                    $composicao->limite_superior = str_replace('.', '', $composicao->limite_superior);
                    $composicao->limite_superior = str_replace(',', '.', $composicao->limite_superior);
                }

                $composicao->save();

                $ids[] = $composicao->id;

                $ids_lista = [];

                foreach ($param['lista'] ?? [] as $paramLista) {

                    if (is_numeric($paramLista['id'])) {

                        $lista = ExameComposicaoLista::where('id', $paramLista['id'])
                            ->first();
                    } else {

                        $lista = new ExameComposicaoLista();
                    }

                    $lista->composicao_id = $composicao->id;
                    $lista->descricao = $paramLista['descricao'];
                    $lista->ordem = $paramLista['ordem'];
                    $lista->situacao_id = $paramLista['situacao_id'];
                    $lista->padrao = $paramLista['padrao'];
                    $lista->save();

                    $ids_lista[] = $lista->id;
                }

                $ids_variavel = [];

                foreach ($param['variavel'] ?? [] as $paramVariavel) {

                    if (is_numeric($paramVariavel['id'])) {

                        $variavel = ExameComposicaoVariavel::where('id', $paramVariavel['id'])
                            ->first();
                    } else {

                        $variavel = new ExameComposicaoVariavel();
                    }

                    $variavel->composicao_id = $composicao->id;
                    $variavel->fator_id = $paramVariavel['fator_id'];
                    $variavel->ordem = $paramVariavel['ordem'];
                    $variavel->save();

                    $ids_variavel[] = $variavel->id;
                }

                ExameComposicaoVariavel::destroy(ExameComposicaoVariavel::where('composicao_id',  $composicao->id)
                    ->whereNotIn('id', $ids_variavel)->pluck('id'));

                ExameComposicaoLista::destroy(ExameComposicaoLista::where('composicao_id',  $composicao->id)
                    ->whereNotIn('id', $ids_lista)->pluck('id'));
            }

            $ids_texto = [];

            foreach ($request['texto_pronto'] ?? [] as $param) {

                if (is_numeric($param['id'])) {

                    $texto = ExameTextoPronto::where('id', $param['id'])
                        ->first();
                } else {

                    $texto = new ExameTextoPronto();
                }

                $texto->exame_id = $id;
                $texto->codigo = $param['codigo'];
                $texto->descricao = $param['descricao'];
                $texto->save();

                $ids_texto[] = $texto->id;
            }

            try {
                ExameTextoPronto::destroy(ExameTextoPronto::where('exame_id',  $id)
                    ->whereNotIn('id', $ids_texto)->pluck('id'));

                ExameComposicao::destroy(ExameComposicao::where('exame_id',  $id)
                    ->whereNotIn('id', $ids)->pluck('id'));
            } catch (Exception $e) {
                throw new DeletingModelException;
            }
        });

        return response()->json($exame->fresh(), Response::HTTP_OK);
    }

    private function getParams($request)
    {
        $params = $request->all();

        if ($params['tipo_id'] == '1') {

            $valor = $params['laboratorio']['valor'];
            $valor = str_replace('.', '', $valor);
            $valor = str_replace(',', '.', $valor);

            $params['prazo_entrega'] = $params['laboratorio']['prazo_entrega'];
            $params['validade'] = $params['laboratorio']['validade'];
            $params['valor'] = $valor;
            $params['quantidade_maxima'] = $params['laboratorio']['quantidade_maxima'];
            $params['outro_municipio'] = $params['laboratorio']['outro_municipio'];
            $params['provisorio'] = $params['laboratorio']['provisorio'];
            $params['sigilo'] = $params['laboratorio']['sigilo'];
            $params['senha_supervisor'] = $params['laboratorio']['senha_supervisor'];
            $params['ultimo_resultado'] = $params['laboratorio']['ultimo_resultado'];
            $params['mapa_agrupado'] = $params['laboratorio']['mapa_agrupado'];
            $params['posicao_mapa'] = $params['laboratorio']['posicao_mapa'];
            $params['valor_sigtap'] = $params['laboratorio']['valor_sigtap'];
            $params['quantidade_reagente'] = $params['laboratorio']['quantidade_reagente'];
            $params['permite_repeticao'] = $params['laboratorio']['permite_repeticao'];
        } else {

            $valor = $params['imagem']['valor'];
            $valor = str_replace('.', '', $valor);
            $valor = str_replace(',', '.', $valor);

            $params['prazo_entrega'] = $params['imagem']['prazo_entrega'];
            $params['validade'] = $params['imagem']['validade'];
            $params['valor'] = $valor;
            $params['quantidade_maxima'] = $params['imagem']['quantidade_maxima'];
            $params['outro_municipio'] = $params['imagem']['outro_municipio'];
            $params['provisorio'] = $params['imagem']['provisorio'];
            $params['senha_supervisor'] = $params['imagem']['senha_supervisor'];
            $params['ultimo_resultado'] = $params['imagem']['ultimo_resultado'];
            $params['resultado'] = $params['imagem']['resultado'];
            $params['valor_sigtap'] = $params['imagem']['valor_sigtap'];
            $params['exigir_peso_altura_circunferencia'] = $params['imagem']['exigir_peso_altura_circunferencia'];
        }

        if ($params['exige_procedimento'] == true) {

            $params['codigo'] = Procedimento::findOrFail($params['procedimento_id'])->codigo;
        }

        if ($params['exige_procedimento'] == false) {

            $params['codigo'] = '';
        }

        $params['valor_ppi'] = str_replace(',', '.', str_replace('.', '', $params['valor_ppi']));

        return $params;
    }

    public function destroy($id)
    {
        $this->auth(__FUNCTION__);

        Exame::findOrFail($id)->delete();

        return response()->json(null, Response::HTTP_NO_CONTENT);
    }

    private function getGrupos()
    {
        return DB::table('cadastro_grupo')
            ->select([
                'cadastro_grupo.id',
                'cadastro_grupo.nome',
            ])
            ->whereExists(fn ($q) => $q->select(DB::raw(1))
                ->from('parametrizacao_exame')
                ->whereColumn('parametrizacao_exame.grupo_tipo_id', 'cadastro_grupo.id')
            )
            ->get();
    }
}