<?php

namespace App\Services\Mobile\ConectaCidadao\EncaminhamentoRegulado;

use App\Enums\Parametrizacao\Exame\Tipo as ExameTipo;
use App\Enums\Regulacao\ParametrizacaoDivulgacaoAba;
use App\Enums\Regulacao\ParametrizacaoDivulgacaoColuna;
use App\Enums\Regulacao\StatusTipo;
use App\Models\Regulacao\Parametrizacao;
use App\Models\Regulacao\Solicitacao;
use App\Services\Service;
use App\Utils\MaskUtil;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\DB;

class EncaminhamentoReguladoService extends Service
{
    public static function meusEncaminhamentos(): array
    {
        $paciente = auth('mobile')->user();
        $perPage = max(1, min((int) request()->input('per_page', 15), 50));
        $page = max((int) request()->input('page', 1), 1);

        $colunasVisiveis = self::getColunasVisiveis();
        $query = self::getSolicitacoesQuery($paciente->id);

        $total = $query->count();
        $solicitacoes = (clone $query)
            ->limit($perPage)
            ->offset(($page - 1) * $perPage)
            ->get();

        if ($solicitacoes->isEmpty()) {

            return [
                'data' => [],
                'total' => 0,
                'page' => $page,
                'per_page' => $perPage,
                'last_page' => 1,
            ];
        }

        $ids = $solicitacoes->pluck('id');
        $exibeStatus = $colunasVisiveis->contains(ParametrizacaoDivulgacaoColuna::STATUS);
        $itensPorSolicitacao = self::getItensPorSolicitacao($ids);
        $prestadoresInternos = self::getPrestadoresInternos($solicitacoes->whereNotNull('prestador_interno_id')->pluck('prestador_interno_id')->unique());
        $prestadoresExternos = self::getPrestadoresExternos($solicitacoes->whereNotNull('prestador_externo_id')->pluck('prestador_externo_id')->unique());

        return [
            'data' => $solicitacoes->map(
                fn($s) => self::formatarSolicitacao($s, $itensPorSolicitacao, $prestadoresInternos, $prestadoresExternos, $exibeStatus)
            )->values()->toArray(),
            'total' => $total,
            'page' => $page,
            'per_page' => $perPage,
            'last_page' => (int) ceil($total / $perPage),
        ];
    }

    public static function documentos(int $id): array
    {
        $paciente = auth('mobile')->user();

        $solicitacao = Solicitacao::where('id', $id)
            ->where('paciente_id', $paciente->id)
            ->whereNotNull('confirmado_em')
            ->with('itens')
            ->firstOrFail();

        $tipos = [['tipo' => 'solicitacao', 'descricao' => 'Protocolo de Solicitação']];

        if (self::hasPreparos($solicitacao)) {

            $tipos[] = ['tipo' => 'preparo', 'descricao' => 'Preparos'];
        }

        $isAgendado = in_array($solicitacao->status->tipo_id, [StatusTipo::AGENDADO, StatusTipo::REAGENDADO]);

        if ($isAgendado) {
            $tipoExame = self::hasExame($solicitacao);

            if ($tipoExame === ExameTipo::LABORATORIAL) {

                $tipos[] = ['tipo' => 'protocolo_agendamento_exame_laboratorial', 'descricao' => 'Protocolo de Agendamento de Exame Laboratorial'];
            } else if ($tipoExame === ExameTipo::IMAGEM) {

                $tipos[] = ['tipo' => 'protocolo_agendamento_exame_imagem', 'descricao' => 'Protocolo de Agendamento de Exame de Imagem'];
            } else if (self::hasProcedimentoCirurgico($solicitacao) && !$solicitacao->prestador_externo_id) {

                $tipos[] = ['tipo' => 'protocolo_agendamento_procedimento_cirurgico', 'descricao' => 'Protocolo de Agendamento de Procedimento Cirúrgico'];
            } else if (self::hasEspecialidade($solicitacao)) {

                $tipos[] = ['tipo' => 'protocolo_agendamento_especialidade', 'descricao' => 'Protocolo de Agendamento de Consulta'];
            }
        }

        return $tipos;
    }

    public static function documentoPorTipo(int $id, string $tipo): array
    {
        $paciente = auth('mobile')->user();

        $solicitacao = Solicitacao::where('id', $id)
            ->where('paciente_id', $paciente->id)
            ->whereNotNull('confirmado_em')
            ->firstOrFail();

        $parametrizacao = Parametrizacao::first();

        if ($tipo === 'solicitacao') {

            return self::documentoSolicitacao($solicitacao, $parametrizacao);
        } else if ($tipo === 'preparo') {

            return self::documentoPreparo($solicitacao);
        } else if (in_array($tipo, ['protocolo_agendamento_exame_laboratorial', 'protocolo_agendamento_exame_imagem'])) {

            return self::documentoProtocoloAgendamentoExame($solicitacao, $tipo, $parametrizacao);
        } else if ($tipo === 'protocolo_agendamento_procedimento_cirurgico') {

            return self::documentoProtocoloAgendamentoProcedimentoCirurgico($solicitacao, $parametrizacao);
        } else if ($tipo === 'protocolo_agendamento_especialidade') {

            return self::documentoProtocoloAgendamentoEspecialidade($solicitacao, $parametrizacao);
        }

        abort(404, 'Tipo de documento não encontrado.');
    }

    private static function getColunasVisiveis(): Collection
    {
        return DB::table('regulacao_parametrizacao_divulgacao_aba_coluna')
            ->whereIn('aba_id', [ParametrizacaoDivulgacaoAba::SOLICITACOES_EM_ESPERA, ParametrizacaoDivulgacaoAba::SOLICITACOES_ATENDIDAS])
            ->where('visivel', true)
            ->pluck('coluna_id');
    }

    private static function getSolicitacoesQuery(int $pacienteId)
    {
        $statusTiposVisiveis = DB::table('regulacao_parametrizacao_divulgacao_aba_status_tipo')
            ->whereIn('aba_id', [ParametrizacaoDivulgacaoAba::SOLICITACOES_EM_ESPERA, ParametrizacaoDivulgacaoAba::SOLICITACOES_ATENDIDAS])
            ->where('visivel', true)
            ->pluck('status_tipo_id');

        return DB::table('regulacao_solicitacao as solicitacao')
            ->join('regulacao_status as status', 'status.id', 'solicitacao.status_id')
            ->join('regulacao_status_tipo as status_tipo', 'status_tipo.id', 'status.tipo_id')
            ->join('regulacao_solicitacao_prioridade as prioridade', 'prioridade.id', 'solicitacao.prioridade_id')
            ->join('cadastro_usuario as usuario_solicitante', 'usuario_solicitante.id', 'solicitacao.usuario_solicitante_id')
            ->join('cadastro_cidadao as cidadao_solicitante', 'cidadao_solicitante.id', 'usuario_solicitante.cidadao_id')
            ->join(
                'regulacao_parametrizacao_divulgacao_regulador as regulador',
                'regulador.regulacao_parametrizacao_regulador_id',
                'solicitacao.regulador_id'
            )
            ->leftJoin('sigtap.cid as cid', 'cid.id', 'solicitacao.cid_id')
            ->where('solicitacao.paciente_id', $pacienteId)
            ->whereNotNull('solicitacao.confirmado_em')
            ->where('regulador.ativo', true)
            ->whereIn('status.tipo_id', $statusTiposVisiveis)
            ->selectRaw("
                solicitacao.id,
                DATE_FORMAT(solicitacao.data, '%d/%m/%Y') as data_pedido,
                cidadao_solicitante.nome as medico_solicitante,
                prioridade.nome as prioridade,
                IF(cid.id IS NOT NULL, CONCAT(cid.codigo, ' - ', cid.nome), NULL) as cid,
                TIMESTAMPDIFF(
                    DAY,
                    (
                        SELECT  STR_TO_DATE(CONCAT(sh.data, ' 00:00:00'), '%Y-%m-%d %H:%i:%s')
                        FROM    regulacao_solicitacao_historico sh
                        JOIN    regulacao_status hs ON hs.id = sh.status_id
                        WHERE   sh.solicitacao_id = solicitacao.id
                        AND     hs.tipo_id = " . StatusTipo::SOLICITADO . "
                        ORDER BY sh.created_at
                        LIMIT 1
                    ),
                    COALESCE((
                        SELECT  sh2.created_at
                        FROM    regulacao_solicitacao_historico sh2
                        JOIN    regulacao_status hs2 ON hs2.id = sh2.status_id
                        WHERE   sh2.solicitacao_id = solicitacao.id
                        AND     hs2.tipo_id IN (" . StatusTipo::AGENDADO . ", " . StatusTipo::REAGENDADO . ")
                        ORDER BY sh2.created_at
                        LIMIT 1
                    ), CURRENT_TIMESTAMP)
                ) as tempo_espera_dias,
                status_tipo.id as status_tipo_id,
                status_tipo.nome as status_nome,
                solicitacao.prestador_interno_id,
                solicitacao.prestador_externo_id,
                DATE_FORMAT(solicitacao.data_agendada, '%d/%m/%Y') as data_agendada,
                DATE_FORMAT(solicitacao.hora_agendada, '%H:%i') as hora_agendada
            ")
            ->orderByDesc('solicitacao.data')
            ->orderByDesc('solicitacao.id');
    }

    private static function getItensPorSolicitacao(Collection $ids): Collection
    {
        return DB::table('regulacao_solicitacao_item as item')
            ->leftJoin('parametrizacao_exame as exame', 'exame.id', 'item.exame_id')
            ->leftJoin('parametrizacao_procedimento_cirurgico as procedimento_cirurgico', 'procedimento_cirurgico.id', 'item.procedimento_cirurgico_id')
            ->leftJoin('cadastro_especialidade as especialidade', 'especialidade.id', 'item.especialidade_id')
            ->whereIn('item.solicitacao_id', $ids)
            ->selectRaw("
                item.solicitacao_id,
                COALESCE(exame.nome, procedimento_cirurgico.nome, especialidade.nome) as descricao
            ")
            ->get()
            ->groupBy('solicitacao_id');
    }

    private static function getPrestadoresInternos(Collection $ids): Collection
    {
        if ($ids->isEmpty()) {

            return collect();
        }

        return DB::table('regulacao_parametrizacao_prestador_interno as prestador_interno')
            ->join('cadastro_infraestrutura as infraestrutura', 'infraestrutura.id', 'prestador_interno.infraestrutura_id')
            ->join('cadastro_unidade as unidade', 'unidade.id', 'infraestrutura.unidade_id')
            ->leftJoin('cadastro_endereco as endereco', 'endereco.id', 'infraestrutura.endereco_id')
            ->leftJoin('cadastro_logradouro as logradouro', 'logradouro.id', 'endereco.logradouro_id')
            ->whereIn('prestador_interno.id', $ids)
            ->selectRaw("
                prestador_interno.id,
                IF(infraestrutura.principal = 1, unidade.nome_fantasia, COALESCE(infraestrutura.nome, unidade.nome_fantasia)) as nome,
                infraestrutura.telefone,
                logradouro.nome as logradouro_nome,
                IF(endereco.numero IS NULL, 'S/N', endereco.numero) as logradouro_numero,
                endereco.complemento as logradouro_complemento
            ")
            ->get()
            ->keyBy('id');
    }

    private static function getPrestadoresExternos(Collection $ids): Collection
    {
        if ($ids->isEmpty()) {

            return collect();
        }

        return DB::table('regulacao_parametrizacao_prestador_externo as prestador_externo')
            ->join('transporte_paciente_destino as destino', 'destino.id', 'prestador_externo.destino_id')
            ->whereIn('prestador_externo.id', $ids)
            ->selectRaw("
                prestador_externo.id,
                destino.descricao_destino as nome,
                COALESCE(destino.numero_telefone_comercial, destino.numero_telefone_fax) as telefone,
                TRIM(CONCAT_WS(', ',
                    NULLIF(destino.nome_logradouro, ''),
                    NULLIF(destino.numero_logradouro, '')
                )) as endereco
            ")
            ->get()
            ->keyBy('id');
    }

    private static function formatarSolicitacao(
        object $s,
        Collection $itensPorSolicitacao,
        Collection $prestadoresInternos,
        Collection $prestadoresExternos,
        bool $exibeStatus
    ): array {
        $result = [
            'id' => $s->id,
            'procedimentos' => self::formatarItens($itensPorSolicitacao[$s->id] ?? collect()),
            'data_pedido' => $s->data_pedido,
            'medico_solicitante' => $s->medico_solicitante,
            'prioridade' => $s->prioridade,
            'cid' => $s->cid,
            'tempo_espera_dias' => is_null($s->tempo_espera_dias) ? null : (int) $s->tempo_espera_dias,
        ];

        if ($exibeStatus) {

            $result['status'] = $s->status_nome;
        }

        if (in_array($s->status_tipo_id, [StatusTipo::AGENDADO, StatusTipo::REAGENDADO])) {

            $result['agendamento'] = self::formatarAgendamento($s, $prestadoresInternos, $prestadoresExternos);
        }

        return $result;
    }

    private static function formatarItens(Collection $itens): array
    {
        return $itens->pluck('descricao')->filter()->unique()->values()->toArray();
    }

    private static function formatarAgendamento(
        object $s,
        Collection $prestadoresInternos,
        Collection $prestadoresExternos
    ): array {
        $prestador = null;

        if (!is_null($s->prestador_interno_id) && $prestadoresInternos->has($s->prestador_interno_id)) {

            $p = $prestadoresInternos->get($s->prestador_interno_id);
            $prestador = [
                'nome' => $p->nome,
                'telefone' => $p->telefone,
                'endereco' => self::formatarEnderecoInterno($p),
            ];
        } else if (!is_null($s->prestador_externo_id) && $prestadoresExternos->has($s->prestador_externo_id)) {

            $p = $prestadoresExternos->get($s->prestador_externo_id);
            $prestador = [
                'nome' => $p->nome,
                'telefone' => $p->telefone,
                'endereco' => $p->endereco ?: null,
            ];
        }

        return [
            'data' => $s->data_agendada,
            'hora' => $s->hora_agendada,
            'prestador' => $prestador,
        ];
    }

    private static function formatarEnderecoInterno(object $prestador): ?string
    {
        if (!$prestador->logradouro_nome) {

            return null;
        }

        return trim(
            $prestador->logradouro_nome
                . ($prestador->logradouro_numero ? ', ' . $prestador->logradouro_numero : '')
                . ($prestador->logradouro_complemento ? ' - ' . $prestador->logradouro_complemento : '')
        );
    }

    private static function getNomeAtendente(Solicitacao $solicitacao): ?string
    {
        $lotacao = $solicitacao->createdLotacao()->withTrashed()->first();

        if (!$lotacao || !$lotacao->usuario || !$lotacao->usuario->cidadao) {

            return null;
        }

        return $lotacao->usuario->cidadao->nome;
    }

    private static function documentoSolicitacao(Solicitacao $solicitacao, ?Parametrizacao $parametrizacao): array
    {
        $itens = $solicitacao->itens()->with(
            [
                'exame',
                'procedimentoCirurgico',
                'especialidade.ocupacao',
            ]
        )->get();

        $examesLaboratoriais = $itens
            ->filter(fn($i) => !is_null($i->exame_id) && $i->exame->tipo_id === ExameTipo::LABORATORIAL)
            ->map(fn($i) => self::formatarItemDocumentoExame($i->exame))
            ->sortBy('descricao')
            ->values();

        $exameImagem = $itens
            ->filter(fn($i) => !is_null($i->exame_id) && $i->exame->tipo_id === ExameTipo::IMAGEM)
            ->first();

        $procedimentoCirurgico = $itens
            ->filter(fn($i) => !is_null($i->procedimento_cirurgico_id))
            ->first();

        $especialidade = $itens
            ->filter(fn($i) => !is_null($i->especialidade_id))
            ->first();

        return [
            'tipo' => 'solicitacao',
            'data_solicitacao' => $solicitacao->data->format('d/m/Y'),
            'hipotese_diagnostica' => $solicitacao->hipotese_diagnostica_justificativa,
            'peso' => $solicitacao->peso ? str_replace('.', ',', $solicitacao->peso) . ' kg' : null,
            'altura' => $solicitacao->altura ? str_replace('.', ',', $solicitacao->altura) . ' cm' : null,
            'exames_laboratoriais' => $examesLaboratoriais->toArray(),
            'exame_imagem' => $exameImagem ? self::formatarItemDocumentoExame($exameImagem->exame) : null,
            'procedimento_cirurgico' => $procedimentoCirurgico ? self::formatarItemDocumentoProcedimento($procedimentoCirurgico->procedimentoCirurgico) : null,
            'especialidade' => $especialidade ? self::formatarItemDocumentoEspecialidade($especialidade->especialidade) : null,
            'solicitante' => [
                'medico' => $solicitacao->usuarioSolicitante->cidadao->nome,
                'unidade' => $solicitacao->infraestruturaSolicitante->unidade->nome_fantasia,
                'infraestrutura' => $solicitacao->infraestruturaSolicitante->nome,
            ],
            'atendente' => self::getNomeAtendente($solicitacao),
            'mensagem' => $parametrizacao ? $parametrizacao->mensagem_protocolo_solicitacao : null,
        ];
    }

    private static function formatarItemDocumentoExame(object $exame): array
    {
        $codigo = empty($exame->codigo) ? null : MaskUtil::getProcedimentoMasked($exame->codigo);

        return [
            'codigo' => $codigo,
            'descricao' => $exame->nome,
        ];
    }

    private static function formatarItemDocumentoProcedimento(object $procedimento): array
    {
        return [
            'codigo' => MaskUtil::getProcedimentoMasked($procedimento->procedimento_codigo),
            'descricao' => $procedimento->nome,
        ];
    }

    private static function formatarItemDocumentoEspecialidade(object $especialidade): array
    {
        return [
            'codigo' => $especialidade->ocupacao->codigo ?? null,
            'descricao' => $especialidade->nome,
        ];
    }

    private static function hasPreparos(Solicitacao $solicitacao): bool
    {
        if (is_null($solicitacao->prestador_interno_id) && is_null($solicitacao->prestador_externo_id)) {

            return false;
        }

        $hasPreparo = false;
        $prestadorRelationName = is_null($solicitacao->prestador_interno_id) ? 'prestadorExterno' : 'prestadorInterno';

        $solicitacao->itens->each(function ($item) use ($solicitacao, &$hasPreparo, $prestadorRelationName) {

            if ($hasPreparo) {

                return false;
            }

            $hasPreparoExame = fn() => !is_null($item->exame_id)
                && $solicitacao->{$prestadorRelationName}->exames()
                ->where('id', $item->exame_id)
                ->wherePivotNotNull('observacoes')
                ->exists();

            $hasPreparoProcedimentoCirurgico = fn() => !is_null($item->procedimento_cirurgico_id)
                && $solicitacao->{$prestadorRelationName}->procedimentosCirurgicos()
                ->where('id', $item->procedimento_cirurgico_id)
                ->wherePivotNotNull('observacoes')
                ->exists();

            $hasPreparoEspecialidade = fn() => !is_null($item->especialidade_id)
                && $solicitacao->{$prestadorRelationName}->especialidades()
                ->where('id', $item->especialidade_id)
                ->wherePivotNotNull('observacoes')
                ->exists();

            if ($hasPreparoExame() || $hasPreparoProcedimentoCirurgico() || $hasPreparoEspecialidade()) {

                $hasPreparo = true;
            }
        });

        return $hasPreparo;
    }

    private static function hasExame(Solicitacao $solicitacao)
    {
        $item = $solicitacao->itens()->with('exame')->whereNotNull('exame_id')->first();

        return ($item && $item->exame) ? $item->exame->tipo_id : false;
    }

    private static function hasProcedimentoCirurgico(Solicitacao $solicitacao): bool
    {
        return $solicitacao->itens()->whereNotNull('procedimento_cirurgico_id')->exists();
    }

    private static function hasEspecialidade(Solicitacao $solicitacao): bool
    {
        return $solicitacao->itens()->whereNotNull('especialidade_id')->exists();
    }

    private static function documentoPreparo(Solicitacao $solicitacao): array
    {
        $itens = collect();
        $prestadorRelationName = is_null($solicitacao->prestador_interno_id) ? 'prestadorExterno' : 'prestadorInterno';

        $solicitacao->itens->each(function ($item) use ($solicitacao, $prestadorRelationName, $itens) {

            if (!is_null($item->exame_id)) {

                $solicitacao->{$prestadorRelationName}->exames()
                    ->where('id', $item->exame_id)
                    ->wherePivotNotNull('observacoes')
                    ->get()
                    ->each(function ($exame) use ($itens) {
                        $itens->push(
                            [
                                'descricao' => empty($exame->codigo)
                                    ? $exame->nome
                                    : MaskUtil::getProcedimentoMasked($exame->codigo) . " - {$exame->nome}",
                                'observacoes' => $exame->pivotPrestadorExame->observacoes,
                            ]
                        );
                    });
            }

            if (!is_null($item->procedimento_cirurgico_id)) {

                $solicitacao->{$prestadorRelationName}->procedimentosCirurgicos()
                    ->where('id', $item->procedimento_cirurgico_id)
                    ->wherePivotNotNull('observacoes')
                    ->get()
                    ->each(function ($procedimento) use ($itens) {
                        $itens->push(
                            [
                                'descricao' => MaskUtil::getProcedimentoMasked($procedimento->procedimento_codigo) . " - {$procedimento->nome}",
                                'observacoes' => $procedimento->pivotPrestadorProcedimentoCirurgico->observacoes,
                            ]
                        );
                    });
            }

            if (!is_null($item->especialidade_id)) {

                $solicitacao->{$prestadorRelationName}->especialidades()
                    ->where('id', $item->especialidade_id)
                    ->wherePivotNotNull('observacoes')
                    ->get()
                    ->each(function ($especialidade) use ($itens) {
                        $itens->push(
                            [
                                'descricao' => "{$especialidade->ocupacao->codigo} - {$especialidade->nome}",
                                'observacoes' => $especialidade->pivotPrestadorEspecialidade->observacoes,
                            ]
                        );
                    });
            }
        });

        return [
            'tipo' => 'preparo',
            'itens' => $itens->sortBy('descricao')->values()->toArray(),
        ];
    }

    private static function formatarPrestadorProtocolo(Solicitacao $solicitacao): ?array
    {
        if ($solicitacao->prestadorInterno) {

            $infra = $solicitacao->prestadorInterno->infraestrutura;

            return [
                'nome' => $infra->principal ? $infra->unidade->nome_fantasia : ($infra->nome ?? $infra->unidade->nome_fantasia),
                'telefone' => $infra->telefone,
                'endereco' => $infra->endereco ? $infra->endereco->enderecoFormatado : null,
            ];
        }

        if ($solicitacao->prestadorExterno) {

            $destino = $solicitacao->prestadorExterno->destino;

            return [
                'nome' => $destino->descricao_destino,
                'telefone' => $destino->numero_telefone_comercial ?? $destino->numero_telefone_fax,
                'endereco' => trim(implode(', ', array_filter(
                    [
                        $destino->nome_logradouro,
                        $destino->numero_logradouro,
                        $destino->nome_bairro,
                    ]
                ))) ?: null,
            ];
        }

        return null;
    }

    private static function formatarPacienteProtocolo(Solicitacao $solicitacao): array
    {
        $cidadao = $solicitacao->paciente->cidadao;
        return [
            'nome' => $cidadao->nome,
            'nome_social' => $cidadao->nome_social,
            'prontuario' => $solicitacao->paciente->prontuario,
            'data_nascimento' => $cidadao->data_nascimento
                ? \Carbon\Carbon::parse($cidadao->data_nascimento)->format('d/m/Y')
                : null,
        ];
    }

    private static function documentoProtocoloAgendamentoExame(
        Solicitacao $solicitacao,
        string $tipo,
        ?Parametrizacao $parametrizacao
    ): array {

        $tipoExame = $tipo === 'protocolo_agendamento_exame_laboratorial' ? ExameTipo::LABORATORIAL : ExameTipo::IMAGEM;

        $itens = $solicitacao->itens()->with('exame')
            ->whereHas('exame', function ($q) use ($tipoExame) {
                $q->where('tipo_id', $tipoExame);
            })
            ->get()
            ->map(function ($item) {
                return [
                    'codigo' => empty($item->exame->codigo) ? null : MaskUtil::getProcedimentoMasked($item->exame->codigo),
                    'descricao' => $item->exame->nome,
                ];
            })
            ->sortBy('descricao')
            ->values()
            ->toArray();

        return [
            'tipo' => $tipo,
            'paciente' => self::formatarPacienteProtocolo($solicitacao),
            'solicitante' => [
                'medico' => $solicitacao->usuarioSolicitante->cidadao->nome,
                'unidade' => $solicitacao->infraestruturaSolicitante->unidade->nome_fantasia,
            ],
            'data_agendamento' => $solicitacao->data_agendada ? $solicitacao->data_agendada->format('d/m/Y') : null,
            'hora_agendamento' => $solicitacao->hora_agendada ? $solicitacao->hora_agendada->format('H:i') : null,
            'prestador' => self::formatarPrestadorProtocolo($solicitacao),
            'itens' => $itens,
            'mensagem' => $parametrizacao ? $parametrizacao->mensagem_comprovante_agendamento : null,
        ];
    }

    private static function documentoProtocoloAgendamentoProcedimentoCirurgico(
        Solicitacao $solicitacao,
        ?Parametrizacao $parametrizacao
    ): array {

        $item = $solicitacao->itens()->with('procedimentoCirurgico')
            ->whereNotNull('procedimento_cirurgico_id')
            ->first();

        $procedimento = null;

        if ($item && $item->procedimentoCirurgico) {

            $procedimento = [
                'codigo' => MaskUtil::getProcedimentoMasked($item->procedimentoCirurgico->procedimento_codigo),
                'descricao' => $item->procedimentoCirurgico->nome,
            ];
        }

        return [
            'tipo' => 'protocolo_agendamento_procedimento_cirurgico',
            'paciente' => self::formatarPacienteProtocolo($solicitacao),
            'solicitante' => [
                'medico' => $solicitacao->usuarioSolicitante->cidadao->nome,
                'unidade' => $solicitacao->infraestruturaSolicitante->unidade->nome_fantasia,
            ],
            'data_agendamento' => $solicitacao->data_agendada ? $solicitacao->data_agendada->format('d/m/Y') : null,
            'hora_agendamento' => $solicitacao->hora_agendada ? $solicitacao->hora_agendada->format('H:i') : null,
            'prestador' => self::formatarPrestadorProtocolo($solicitacao),
            'procedimento' => $procedimento,
            'mensagem' => $parametrizacao ? $parametrizacao->mensagem_comprovante_agendamento : null,
        ];
    }

    private static function documentoProtocoloAgendamentoEspecialidade(
        Solicitacao $solicitacao,
        ?Parametrizacao $parametrizacao
    ): array {

        $item = $solicitacao->itens()->with('especialidade.ocupacao')
            ->whereNotNull('especialidade_id')
            ->first();

        $especialidade = null;

        if ($item && $item->especialidade) {

            $especialidade = [
                'codigo' => $item->especialidade->ocupacao->codigo ?? null,
                'descricao' => $item->especialidade->nome,
            ];
        }

        return [
            'tipo' => 'protocolo_agendamento_especialidade',
            'paciente' => self::formatarPacienteProtocolo($solicitacao),
            'solicitante' => [
                'medico' => $solicitacao->usuarioSolicitante->cidadao->nome,
                'unidade' => $solicitacao->infraestruturaSolicitante->unidade->nome_fantasia,
            ],
            'data_agendamento' => $solicitacao->data_agendada ? $solicitacao->data_agendada->format('d/m/Y') : null,
            'hora_agendamento' => $solicitacao->hora_agendada ? $solicitacao->hora_agendada->format('H:i') : null,
            'prestador' => self::formatarPrestadorProtocolo($solicitacao),
            'especialidade' => $especialidade,
            'mensagem' => $parametrizacao ? $parametrizacao->mensagem_comprovante_agendamento : null,
        ];
    }
}