<?php

namespace App\Services\AtencaoBasica\FichaComplementar;

use App\Enums\AtencaoBasica\FichaComplementar\CDSOrigem;
use App\Enums\AtencaoBasica\Parametrizacao\Permissao;
use App\Models\AtencaoBasica\FichaComplementar\FichaComplementar;
use App\Models\AtencaoBasica\FichaComplementar\FichaComplementarFundoOlho;
use App\Models\AtencaoBasica\FichaComplementar\FichaComplementarRessonanciaMagnetica;
use App\Models\AtencaoBasica\FichaComplementar\FichaComplementarTesteOlho;
use App\Models\AtencaoBasica\FichaComplementar\FichaComplementarTesteOrelha;
use App\Models\AtencaoBasica\FichaComplementar\FichaComplementarTomografiaComputadorizada;
use App\Models\AtencaoBasica\FichaComplementar\FichaComplementarUsTransfontanela;
use App\Models\AtencaoBasica\Parametrizacao\OutrosPermissaoOcupacao;
use App\Models\Cadastro\Estabelecimento\Unidade;
use App\Models\Cadastro\SujeitoAtencao\Usuario;
use App\Models\Geral\Turno;
use App\Services\Service;
use App\Utils\AtencaoBasica\EsusUtil;
use App\Utils\AtencaoBasica\EsusUtil\Eloquent\Model;
use App\Utils\AtencaoBasica\EsusUtil\Query\Builder;
use Carbon\Carbon;
use Illuminate\Http\Collection;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;

class FichaComplementarService extends Service
{
    /**
     * @param int $pacienteId
     * @return Collection
     */
    private static function getHistoricoFichaComplementar(int $pacienteId)
    {
        return DB::table('atencao_basica_ficha_complementar')
            ->join('cadastro_paciente', 'cadastro_paciente.id', '=', 'atencao_basica_ficha_complementar.paciente_id')
            ->join('cadastro_cidadao', 'cadastro_paciente.cidadao_id', '=', 'cadastro_cidadao.id')
            ->join('cadastro_unidade', 'cadastro_unidade.id', '=', 'atencao_basica_ficha_complementar.unidade_id')
            ->join('cadastro_usuario', 'cadastro_usuario.id', '=', 'atencao_basica_ficha_complementar.usuario_id')
            ->join('cadastro_cidadao as cidadao_usuario', 'cidadao_usuario.id', '=', 'cadastro_usuario.cidadao_id')
            ->join('geral_turno', 'geral_turno.id', '=', 'atencao_basica_ficha_complementar.turno_id')
            ->leftJoin('cadastro_usuario as usuario_exportacao', 'usuario_exportacao.id', 'atencao_basica_ficha_complementar.usuario_exportacao_id')
            ->leftJoin('cadastro_cidadao as cidadao_exportacao', 'cidadao_exportacao.id', 'usuario_exportacao.cidadao_id')
            ->leftJoin('atencao_basica_exportacao as exportacao', 'exportacao.id', 'atencao_basica_ficha_complementar.exportacao_id')
            ->select(
                'atencao_basica_ficha_complementar.id',
                'cadastro_cidadao.nome',
                'cadastro_cidadao.preferencia_nome_id AS preferencia_nome_id',
                'cadastro_cidadao.nome_social AS nome_social',
                DB::raw('UPPER(cidadao_usuario.nome) AS profissional'),
                'cadastro_unidade.nome_fantasia AS unidade',
                DB::raw("
                    DATE_FORMAT(atencao_basica_ficha_complementar.data_atendimento, '%d/%m/%Y') AS data_atendimento
                "),
                DB::raw('UPPER(geral_turno.nome) AS turno'),
                '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"),
            )
            ->where('cadastro_paciente.id', $pacienteId)
            ->get();
    }


    /**
     * @param int $pacienteId
     * @return array
     */
    public static function historico(int $pacienteId)
    {
        return [
            'form' => self::getHistoricoFichaComplementar($pacienteId),
            'paciente' => self::getPaciente($pacienteId)
        ];
    }

    /**
     * @param int $pacienteId
     * @return Builder|Model|object|null
     */
    private static function getPaciente(int $pacienteId)
    {
        return DB::table('cadastro_paciente')
            ->join(
                'cadastro_cidadao',
                'cadastro_cidadao.id',
                '=',
                'cadastro_paciente.cidadao_id'
            )
            ->select(
                'cadastro_paciente.id',
                'cadastro_paciente.subclassificacao_id',
                DB::raw("IFNULL(concat(cadastro_cidadao.nome, ' (', cadastro_cidadao.nome_social, ')'), cadastro_cidadao.nome) as nome"),
                'cadastro_cidadao.cns',
                DB::raw("DATE_FORMAT(cadastro_cidadao.data_nascimento, '%d/%m/%Y') AS data_nascimento")
            )
            ->where('cadastro_paciente.id', $pacienteId)
            ->first();
    }

    /**
     * @return Turno[]|\Illuminate\Database\Eloquent\Collection|Collection
     */
    private static function getTurnos()
    {
        return Turno::all()->map(fn ($turno) => ['value' => $turno->id, 'text' => $turno->nome]);
    }

    /**
     * @return FichaComplementarTesteOlho[]|\Illuminate\Database\Eloquent\Collection|Collection
     */
    private static function getResultadoTesteOlhinho()
    {
        return FichaComplementarTesteOlho::all()->map(fn ($testeOlhinho) => [
            'value' => $testeOlhinho->id, 'text' => $testeOlhinho->descricao
        ]);
    }

    /**
     * @return FichaComplementarFundoOlho[]|\Illuminate\Database\Eloquent\Collection|Collection
     */
    private static function getResultadoExameFundoOlho()
    {
        return FichaComplementarFundoOlho::all()->map(fn ($exameFundoOlho) => [
            'value' => $exameFundoOlho->id, 'text' => $exameFundoOlho->descricao
        ]);
    }

    /**
     * @return FichaComplementarTesteOrelha[]|\Illuminate\Database\Eloquent\Collection|Collection
     */
    private static function getResultadoTesteOrelhinha()
    {
        return FichaComplementarTesteOrelha::all()->map(fn ($testeOrelhinha) => [
            'value' => $testeOrelhinha->id, 'text' => $testeOrelhinha->descricao
        ]);
    }

    /**
     * @return FichaComplementarUsTransfontanela[]|\Illuminate\Database\Eloquent\Collection|Collection
     */
    private static function getResultadoUsTransfontanela()
    {
        return FichaComplementarUsTransfontanela::all()->map(fn ($usTransfontanela) => [
            'value' => $usTransfontanela->id, 'text' => $usTransfontanela->descricao
        ]);
    }

    /**
     * @return FichaComplementarTomografiaComputadorizada[]|\Illuminate\Database\Eloquent\Collection|Collection
     */
    private static function getResultadoTomografiaComputadorizada()
    {
        return FichaComplementarTomografiaComputadorizada::all()->map(fn ($tomografiaComputadorizada) => [
            'value' => $tomografiaComputadorizada->id, 'text' =>  $tomografiaComputadorizada->descricao
        ]);
    }

    /**
     * @return FichaComplementarRessonanciaMagnetica[]|\Illuminate\Database\Eloquent\Collection|Collection
     */
    private static function getResultadoRessonanciaMagnetica()
    {
        return FichaComplementarRessonanciaMagnetica::all()->map(fn ($ressonanciaMagnetica) => [
            'value' => $ressonanciaMagnetica->id, 'text' => $ressonanciaMagnetica->descricao
        ]);
    }

    /**
     * @param int $pacienteId
     * @return array
     */
    public static function create(int $pacienteId)
    {
        return [
            'form' => [
                'data_atual' => Carbon::now()->format('Y-m-d'),
                'informacoes_paciente' => self::getPaciente($pacienteId),
                'turnos' => self::getTurnos(),
                'exames' => [
                    'teste_olhinho' => self::getResultadoTesteOlhinho(),
                    'fundo_olho' => self::getResultadoExameFundoOlho(),
                    'teste_orelhinha' => self::getResultadoTesteOrelhinha(),
                    'us_transfontanela' => self::getResultadoUsTransfontanela(),
                    'tomografia_computadorizada' => self::getResultadoTomografiaComputadorizada(),
                    'ressonancia_magnetica' => self::getResultadoRessonanciaMagnetica()
                ]
            ]
        ];
    }

    /**
     * @param int $unidadeId
     * @return string
     */
    private static function geraFichaUuid(int $unidadeId)
    {
        $unidade = Unidade::findOrFail($unidadeId);
        $uuid = EsusUtil::v4UUID();

        return "{$unidade->cnes}-{$uuid}";
    }

    /**
     * @param Request $request
     * @return array
     */
    private static function getParams($request)
    {
        return [
            'paciente_id' => $request->paciente,
            'usuario_id' => $request->usuario,
            'cbo_id' => $request->cbo,
            'unidade_id' => $request->unidade,
            'equipe_id' => $request->equipe,
            'tipo_cds_origem' => CDSOrigem::SISTEMA_TERCEIROS,
            'turno_id' => $request->turno,
            'data_atendimento' => Carbon::parse($request->data_atendimento)->format('Y-m-d'),
            'data_realizacao_teste_olhinho' => !is_null($request->data['teste_olhinho'])
                ? Carbon::parse($request->data['teste_olhinho'])->format('Y-m-d')
                : null,
            'resultado_teste_olhinho_id' => !is_null($request->resultado['teste_olhinho'])
                ? $request->resultado['teste_olhinho']
                : null,
            'data_realizacao_fundo_olho' => !is_null($request->data['fundo_olho'])
                ? Carbon::parse($request->data['fundo_olho'])->format('Y-m-d')
                : null,
            'resultado_fundo_olho_id' => !is_null($request->resultado['fundo_olho'])
                ? $request->resultado['fundo_olho']
                : null,
            'data_realizacao_teste_orelhinha' => !is_null($request->data['teste_orelhinha'])
                ? Carbon::parse($request->data['teste_orelhinha'])->format('Y-m-d')
                : null,
            'resultado_teste_orelhinha_id' => !is_null($request->resultado['teste_orelhinha'])
                ? $request->resultado['teste_orelhinha']
                : null,
            'data_realizacao_us_transfontanela' => !is_null($request->data['us_transfontanela'])
                ? Carbon::parse($request->data['us_transfontanela'])->format('Y-m-d')
                : null,
            'resultado_us_transfontanela_id' => !is_null($request->resultado['us_transfontanela'])
                ? $request->resultado['us_transfontanela']
                : null,
            'data_realizacao_tomografia_computadorizada' => !is_null($request->data['tomografia_computadorizada'])
                ? Carbon::parse($request->data['tomografia_computadorizada'])->format('Y-m-d')
                : null,
            'resultado_tomografia_computadorizada_id' => !is_null($request->resultado['tomografia_computadorizada'])
                ? $request->resultado['tomografia_computadorizada']
                : null,
            'data_realizacao_ressonancia_magnetica' => !is_null($request->data['ressonancia_magnetica'])
                ? Carbon::parse($request->data['ressonancia_magnetica'])->format('Y-m-d')
                : null,
            'resultado_ressonancia_magnetica_id' => !is_null($request->resultado['ressonancia_magnetica'])
                ? $request->resultado['ressonancia_magnetica']
                : null,
            'latitude' => !is_null($request->latitude)
                ? $request->latitude
                : null,
            'longitude' => !is_null($request->longitude)
                ? $request->longitude
                : null,
        ];
    }

    /**
     * @param Request $request
     * @return void
     */
    public static function store(Request $request)
    {

        self::saveStore($request);
    }

    public static function saveStore($request)
    {
        $params = self::getParams((object) $request);

        DB::transaction(function () use ($params) {
            $params = array_merge($params, ['uuid_ficha' => self::geraFichaUuid($params['unidade_id'])]);
            FichaComplementar::create($params);
        });
    }

    /**
     * @param int $id
     * @return mixed
     */
    private static function getFichaComplementar(int $id)
    {
        return FichaComplementar::findOrFail($id);
    }

    /**
     * @param int $fichaComplementarId
     * @return array[]
     */
    public static function edit(int $fichaComplementarId)
    {
        $fichaComplementar = self::getFichaComplementar($fichaComplementarId);

        $form = [
            'informacoes_paciente' => self::getPaciente($fichaComplementar->paciente_id),
            'turnos' => self::getTurnos(),
            'exames' => [
                'teste_olhinho' => self::getResultadoTesteOlhinho(),
                'fundo_olho' => self::getResultadoExameFundoOlho(),
                'teste_orelhinha' => self::getResultadoTesteOrelhinha(),
                'us_transfontanela' => self::getResultadoUsTransfontanela(),
                'tomografia_computadorizada' => self::getResultadoTomografiaComputadorizada(),
                'ressonancia_magnetica' => self::getResultadoRessonanciaMagnetica()
            ],
        ];

        $model = [
            'profissional' => [
                'id' => $fichaComplementar->usuario->id ?? null,
                'cidadao_nome' => $fichaComplementar->usuario->cidadao->nome ?? null,
            ],
            'turno' => $fichaComplementar->turno_id,
            'unidade' => $fichaComplementar->unidade_id,
            'infraestrutura' => $fichaComplementar->equipe->infraestrutura_id ?? null,
            'cbo' => $fichaComplementar->cbo_id,
            'equipe' => $fichaComplementar->equipe_id,
            'data_atendimento' => $fichaComplementar->data_atendimento,
            'datas' => [
                'teste_olhinho' => $fichaComplementar->data_realizacao_teste_olhinho,
                'fundo_olho' => $fichaComplementar->data_realizacao_fundo_olho,
                'teste_orelhinha' => $fichaComplementar->data_realizacao_teste_orelhinha,
                'us_transfontanela' => $fichaComplementar->data_realizacao_us_transfontanela,
                'tomografia_computadorizada' => $fichaComplementar->data_realizacao_tomografia_computadorizada,
                'ressonancia_magnetica' => $fichaComplementar->data_realizacao_ressonancia_magnetica
            ],
            'resultados' => [
                'teste_olhinho' => $fichaComplementar->resultado_teste_olhinho_id,
                'fundo_olho' => $fichaComplementar->resultado_fundo_olho_id,
                'teste_orelhinha' => $fichaComplementar->resultado_teste_orelhinha_id,
                'us_transfontanela' => $fichaComplementar->resultado_us_transfontanela_id,
                'tomografia_computadorizada' => $fichaComplementar->resultado_tomografia_computadorizada_id,
                'ressonancia_magnetica' => $fichaComplementar->resultado_ressonancia_magnetica_id
            ]
        ];

        return ['form' => $form, 'model' => $model];
    }

    /**
     * @param int $fichaComplementarId
     * @param Request $request
     * @return void
     */
    public static function update(int $fichaComplementarId, Request $request)
    {
        $fichaComplementar = self::getFichaComplementar($fichaComplementarId);
        $params = self::getParams($request);

        DB::transaction(function () use ($fichaComplementar, $params) {
            $params = array_merge($params, ['uuid_ficha' => self::geraFichaUuid($params['unidade_id'])]);
            $fichaComplementar->fill($params)->save();
        });
    }

    /**
     * @param int $fichaComplementarId
     * @return void
     */
    public static function destroy(int $fichaComplementarId)
    {
        $fichaComplementar = self::getFichaComplementar($fichaComplementarId);

        DB::transaction(function () use ($fichaComplementarId, $fichaComplementar) {
            $fichaComplementar->delete($fichaComplementarId);
        });
    }

    public static function getEquipes(){

        return DB::table('atencao_basica_parametrizacao_equipe_usuario')
            ->select([
                'atencao_basica_parametrizacao_equipe.id AS id',
                DB::raw("CONCAT(
                    'INE: ', atencao_basica_parametrizacao_area.numero_ine,
                    CASE
                        WHEN atencao_basica_parametrizacao_area.descricao
                        THEN CONCAT(' - Área: ', atencao_basica_parametrizacao_area.descricao)
                        ELSE ''
                    END,
                    ' - Microárea: ', 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')
            ->join('atencao_basica_parametrizacao_area', 'atencao_basica_parametrizacao_area.id', 'atencao_basica_parametrizacao_equipe.area_id')
            ->join('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(request()->infraestrutura_id, fn ($q, $id) => $q->where('atencao_basica_parametrizacao_equipe.infraestrutura_id', $id))
            ->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 getUnidades(){

        return DB::table('atencao_basica_parametrizacao_equipe_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', 'atencao_basica_parametrizacao_equipe.id', 'atencao_basica_parametrizacao_equipe_usuario.equipe_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))
            ->distinct()
            ->get();
    }

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

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