<?php

namespace App\Services\Raas;

use App\Services\Service;
use App\Utils\DataUtil;
use App\Utils\MaskUtil;
use Illuminate\Support\Facades\DB;

class RelatorioInconsistenciaService extends Service
{
    public static function index()
    {
        $params = self::getParams();

        $inconsistencias = collect();

        if ($params->tipo_inconsistencia === 'atendimento') {
            $inconsistencias = DB::table('raas_atendimento')
                ->select([
                    'raas_atendimento.id AS atendimento_id',
                    DB::raw("DATE_FORMAT(raas_atendimento.data_admissao, '%d/%m/%Y') AS data_admissao"),
                    DB::raw("DATE_FORMAT(raas_atendimento.data_conclusao, '%d/%m/%Y') AS data_conclusao"),
                    'cadastro_unidade.nome_fantasia AS unidade_nome_fantasia',
                    'cadastro_cidadao.nome AS paciente_nome',
                    'cadastro_cidadao.cns AS paciente_cns',
                    'cid.codigo AS cid_codigo',
                    'cid.nome AS cid_nome',
                ])
                ->join('cadastro_unidade', 'cadastro_unidade.id', 'raas_atendimento.unidade_id')
                ->join('cadastro_paciente', 'cadastro_paciente.id', 'raas_atendimento.paciente_id')
                ->join('cadastro_cidadao', 'cadastro_cidadao.id', 'cadastro_paciente.cidadao_id')
                ->leftJoin('sigtap.cid', 'cid.id', 'raas_atendimento.cid_principal_id')
                ->whereExists(fn($q) => $q->select(DB::raw(1))
                    ->from('raas_atendimento_inconsistencia')
                    ->whereColumn('raas_atendimento_inconsistencia.atendimento_id', 'raas_atendimento.id')
                )
                ->where('raas_atendimento.competencia_id', $params->competencia_id)
                ->when($params->unidade_id, fn($q, $unidadeId) => $q->where('raas_atendimento.unidade_id', $unidadeId));

            self::setOrderBy($inconsistencias);

            $inconsistencias = $inconsistencias->get()
                ->map(function ($query) {
                    $inconsistencia = [
                        'atendimento_id' => $query->atendimento_id,
                        'data_admissao' => $query->data_admissao,
                        'data_conclusao' => $query->data_conclusao,
                        'unidade_nome_fantasia' => $query->unidade_nome_fantasia,
                        'paciente_nome' => $query->paciente_nome,
                        'paciente_cns' => MaskUtil::getCnsMasked($query->paciente_cns),
                        'cid' => $query->cid_codigo . ' - ' . $query->cid_nome,
                        'inconsistencias' => DB::table('raas_atendimento_inconsistencia')
                            ->select(['raas_inconsistencia.descricao AS inconsistencia_descricao'])
                            ->join('raas_inconsistencia', 'raas_inconsistencia.id', 'raas_atendimento_inconsistencia.inconsistencia_id')
                            ->where('raas_atendimento_inconsistencia.atendimento_id', $query->atendimento_id)
                            ->get()
                    ];

                    return $inconsistencia;
                });
        }
        else if ($params->tipo_inconsistencia === 'procedimento') {
            $inconsistencias = DB::table('raas_atendimento_procedimento')
                ->select([
                    'raas_atendimento.id AS atendimento_id',
                    'raas_atendimento_procedimento.id AS atendimento_procedimento_id',
                    DB::raw("DATE_FORMAT(raas_atendimento.data_admissao, '%d/%m/%Y') AS data_admissao"),
                    DB::raw("DATE_FORMAT(raas_atendimento.data_conclusao, '%d/%m/%Y') AS data_conclusao"),
                    'cadastro_unidade.nome_fantasia AS unidade_nome_fantasia',
                    'cadastro_cidadao.nome AS paciente_nome',
                    'cadastro_cidadao.cns AS paciente_cns',
                    'procedimento.codigo AS procedimento_codigo',
                    'procedimento.nome AS procedimento_nome',
                    'registro.nome AS registro_nome',
                    'cid.codigo AS cid_codigo',
                    'cid.nome AS cid_nome',
                ])
                ->join('raas_atendimento', 'raas_atendimento.id', 'raas_atendimento_procedimento.atendimento_id')
                ->join('cadastro_unidade', 'cadastro_unidade.id', 'raas_atendimento.unidade_id')
                ->join('cadastro_paciente', 'cadastro_paciente.id', 'raas_atendimento.paciente_id')
                ->join('cadastro_cidadao', 'cadastro_cidadao.id', 'cadastro_paciente.cidadao_id')
                ->join('sigtap.procedimento', 'procedimento.id', 'raas_atendimento_procedimento.procedimento_id')
                ->join('sigtap.procedimento_registro', 'procedimento_registro.procedimento_id', 'procedimento.id')
                ->join('sigtap.registro', 'registro.id', 'procedimento_registro.registro_id')
                ->leftJoin('sigtap.cid', 'cid.id', 'raas_atendimento.cid_principal_id')
                ->whereExists(fn($q) => $q->select(DB::raw(1))
                    ->from('raas_atendimento_procedimento_inconsistencia')
                    ->whereColumn('raas_atendimento_procedimento_inconsistencia.atendimento_procedimento_id', 'raas_atendimento_procedimento.id')
                )
                ->where('raas_atendimento.competencia_id', $params->competencia_id)
                ->when($params->unidade_id, fn($q, $unidadeId) => $q->where('raas_atendimento.unidade_id', $unidadeId));

            self::setOrderBy($inconsistencias);

            $inconsistencias = $inconsistencias->get()
                ->map(function ($query) {
                    $inconsistencia = [
                        'atendimento_id' => $query->atendimento_id,
                        'data_admissao' => $query->data_admissao,
                        'data_conclusao' => $query->data_conclusao,
                        'unidade_nome_fantasia' => $query->unidade_nome_fantasia,
                        'paciente_nome' => $query->paciente_nome,
                        'paciente_cns' => MaskUtil::getCnsMasked($query->paciente_cns),
                        'registro_nome' => $query->registro_nome,
                        'procedimento' => MaskUtil::getProcedimentoMasked($query->procedimento_codigo) . ' - ' . $query->procedimento_nome,
                        'cid' => $query->cid_codigo . ' - ' . $query->cid_nome,
                        'inconsistencias' => DB::table('raas_atendimento_procedimento_inconsistencia')
                            ->select(['raas_inconsistencia.descricao AS inconsistencia_descricao'])
                            ->join('raas_inconsistencia', 'raas_inconsistencia.id', 'raas_atendimento_procedimento_inconsistencia.inconsistencia_id')
                            ->where('raas_atendimento_procedimento_inconsistencia.atendimento_procedimento_id', $query->atendimento_procedimento_id)
                            ->get(),
                    ];

                    return $inconsistencia;
                });
        }

        return ['itens' => $inconsistencias];
    }

    public static function create()
    {
        return [
            'form' => [
                'competencias' => self::getCompetencias(),
                'tipos_inconsistencia' => [],
                'unidades' => [],
            ],
            'model' => [
                'competencia_id' => null,
                'tipo_inconsistencia' => null,
                'unidade_id' => null,
            ],
        ];
    }

    public static function list()
    {
        $params = self::getParams();

        switch (request()->listar) {
            case 'tipos-inconsistencia': {
                return [
                    'tipos_inconsistencia' => self::getTiposInconsistencia($params),
                ];
            }
            case 'unidades': {
                return [
                    'unidades' => self::getUnidades($params),
                ];
            }
        }
    }

    private static function getParams()
    {
        return (object) [
            'competencia_id' => request()->get('competencia_id'),
            'tipo_inconsistencia' => request()->get('tipo_inconsistencia'),
            'unidade_id' => request()->get('unidade_id'),
        ];
    }

    private static function getCompetencias()
    {
        return DB::table('sigtap.competencia')
            ->select([
                'competencia.id',
                'competencia.valor',
            ])
            ->whereExists(fn($q) => $q->select(DB::raw(1))
                ->from('raas_atendimento_inconsistencia')
                ->join('raas_atendimento', 'raas_atendimento.id', 'raas_atendimento_inconsistencia.atendimento_id')
                ->whereColumn('raas_atendimento.competencia_id', 'competencia.id')
            )
            ->orWhereExists(fn($q) => $q->select(DB::raw(1))
                ->from('raas_atendimento_procedimento_inconsistencia')
                ->join('raas_atendimento_procedimento', 'raas_atendimento_procedimento.id', 'raas_atendimento_procedimento_inconsistencia.atendimento_procedimento_id')
                ->join('raas_atendimento', 'raas_atendimento.id', 'raas_atendimento_procedimento.atendimento_id')
                ->whereColumn('raas_atendimento.competencia_id', 'competencia.id')
            )
            ->orderByDesc('competencia.valor')
            ->get();
    }

    private static function getTiposInconsistencia($params)
    {
        $tipos = [];

        $atendimento = DB::table('raas_atendimento')
            ->whereExists(fn($q) => $q->select(DB::raw(1))
                ->from('raas_atendimento_inconsistencia')
                ->whereColumn('raas_atendimento_inconsistencia.atendimento_id', 'raas_atendimento.id')
            )
            ->where('raas_atendimento.competencia_id', $params->competencia_id)
            ->exists();

        $procedimento = DB::table('raas_atendimento')
            ->whereExists(fn($q) => $q->select(DB::raw(1))
                ->from('raas_atendimento_procedimento_inconsistencia')
                ->join('raas_atendimento_procedimento', 'raas_atendimento_procedimento.id', 'raas_atendimento_procedimento_inconsistencia.atendimento_procedimento_id')
                ->whereColumn('raas_atendimento_procedimento.atendimento_id', 'raas_atendimento.id')
            )
            ->where('raas_atendimento.competencia_id', $params->competencia_id)
            ->exists();

        if ($atendimento) {
            $tipos[] = [
                'valor' => 'atendimento',
                'descricao' => 'Atendimento',
            ];
        }

        if ($procedimento) {
            $tipos[] = [
                'valor' => 'procedimento',
                'descricao' => 'Procedimento',
            ];
        }

        return $tipos;
    }

    private static function getUnidades($params)
    {
        return DB::table('cadastro_unidade')
            ->select([
                'cadastro_unidade.id',
                'cadastro_unidade.nome_fantasia',
            ])
            ->when($params->tipo_inconsistencia, function ($query, $tipoInconsistencia) use ($params) {
                if ($tipoInconsistencia === 'atendimento') {
                    $query->whereExists(fn($q) => $q->select(DB::raw(1))
                        ->from('raas_atendimento_inconsistencia')
                        ->join('raas_atendimento', 'raas_atendimento.id', 'raas_atendimento_inconsistencia.atendimento_id')
                        ->whereColumn('raas_atendimento.unidade_id', 'cadastro_unidade.id')
                        ->where('raas_atendimento.competencia_id', $params->competencia_id)
                    );
                }
                else if ($tipoInconsistencia === 'procedimento') {
                    $query->whereExists(fn($q) => $q->select(DB::raw(1))
                        ->from('raas_atendimento_procedimento_inconsistencia')
                        ->join('raas_atendimento_procedimento', 'raas_atendimento_procedimento.id', 'raas_atendimento_procedimento_inconsistencia.atendimento_procedimento_id')
                        ->join('raas_atendimento', 'raas_atendimento.id', 'raas_atendimento_procedimento.atendimento_id')
                        ->whereColumn('raas_atendimento.unidade_id', 'cadastro_unidade.id')
                        ->where('raas_atendimento.competencia_id', $params->competencia_id)
                    );
                }
            })
            ->orderBy('cadastro_unidade.nome_fantasia')
            ->get();
    }

    private static function setOrderBy($builder)
    {
        $columns = [];

        if (request()->tipo_inconsistencia === 'atendimento') {
            $columns = [
                'data_admissao' => DB::raw("DATE_FORMAT(raas_atendimento.data_admissao, '%d/%m/%Y')"),
                'data_conclusao' => DB::raw("DATE_FORMAT(raas_atendimento.data_conclusao, '%d/%m/%Y')"),
                'unidade_nome_fantasia' => 'cadastro_unidade.nome_fantasia',
                'paciente_nome' => 'cadastro_cidadao.nome',
                'paciente_cns' => 'cadastro_cidadao.cns',
                'cid' => 'cid.codigo',
            ];
        }
        else if (request()->tipo_inconsistencia === 'procedimento') {
            $columns = [
                'data_admissao' => DB::raw("DATE_FORMAT(raas_atendimento.data_admissao, '%d/%m/%Y')"),
                'data_conclusao' => DB::raw("DATE_FORMAT(raas_atendimento.data_conclusao, '%d/%m/%Y')"),
                'unidade_nome_fantasia' => 'cadastro_unidade.nome_fantasia',
                'paciente_nome' => 'cadastro_cidadao.nome',
                'paciente_cns' => 'cadastro_cidadao.cns',
                'procedimento' => 'procedimento.codigo',
                'registro_nome' => 'registro.nome',
                'cid' => 'cid.codigo',
            ];
        }

        if (is_null(request()->sort_by)) {
            $builder->orderByRaw(join(', ', $columns));

            return;
        }

        $column = $columns[request()->sort_by];
        $direction = DataUtil::getBooleanValueFromStringBoolean(request()->sort_desc) ? 'DESC' : 'ASC';

        unset($columns[request()->sort_by]);

        $builder->orderByRaw(
            "{$column} {$direction}, " . join(', ', $columns)
        );
    }
}