<?php

namespace App\Services\AtencaoBasica\Exportacao;

use App\Enums\AtencaoBasica\Exportacao\Status;
use App\Exceptions\AtencaoBasica\ArquivoException;
use App\Exceptions\AtencaoBasica\ExportacaoEmAndamentoException;
use App\Exceptions\AtencaoBasica\NaoExisteFichaException;
use App\Jobs\AtencaoBasica\ExportacaoJob;
use App\Models\AtencaoBasica\AtencaoBasicaVersaoIntegradorEsus;
use App\Models\AtencaoBasica\AtendimentoDomiciliar\AtendimentoDomiciliar;
use App\Models\AtencaoBasica\AtendimentoIndividual\AtendimentoIndividual;
use App\Models\AtencaoBasica\AtendimentoOdontologico\AtendimentoOdontologico;
use App\Models\AtencaoBasica\AtividadeColetiva\AtividadeColetiva;
use App\Models\AtencaoBasica\Avaliacao\Avaliacao;
use App\Models\AtencaoBasica\CadastroDomiciliar\CadastroDomiciliar;
use App\Models\AtencaoBasica\CadastroIndividual\CadastroIndividual;
use App\Models\AtencaoBasica\Exportacao\Exportacao;
use App\Models\AtencaoBasica\Exportacao\ExportacaoArquivo;
use App\Models\AtencaoBasica\FichaComplementar\FichaComplementar;
use App\Models\AtencaoBasica\MarcadorConsumoAlimentar\MarcadorConsumoAlimentar;
use App\Models\AtencaoBasica\Procedimento\Procedimento;
use App\Models\AtencaoBasica\VisitaDomiciliar\VisitaDomiciliar;
use App\Services\AtencaoBasica\Exportacao\FichaAtendimentoIndividualService;
use App\Services\AtencaoBasica\Exportacao\FichaAtendimentoOdontologicoService;
use App\Services\AtencaoBasica\Exportacao\FichaCadastroIndividualService;
use App\Services\AtencaoBasica\Exportacao\FichaConsumoAlimentarMenosSeisMesesService;
use App\Services\AtencaoBasica\Exportacao\FichaProcedimentoService;
use App\Services\Service;
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\File;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Str;

class ExportacaoService extends Service
{
    const BASE_PATH = 'atencao-basica' . DIRECTORY_SEPARATOR . 'exportacao' . DIRECTORY_SEPARATOR;

    public static function index($request)
    {
        switch ($request->listar) {
            case 'fichas':
                return self::getFichasExportadas($request);
        }
    }

    public static function create()
    {
         return [
            'arquivos_exportados' => self::getArquivosExportados(),
            'form' => [
                'competencias' => self::getCompetencias(),
                'competencias_fichas_exportadas' => self::getCompetenciasFichasExportadas(),
                'versaoIntegradorEsus' => self::getVersaoIntegradorEsus(),
            ],
            'model' => [
                'competencia' => null,
                'competencia_ficha_exportada' => null,
            ],
        ];
    }

    public static function store($request)
    {
        if (self::hasExportacaoEmAndamento()) {
            throw new ExportacaoEmAndamentoException();
        }

        self::validate($request);

        if (self::hasFichasParaExportacao($request->competencia)) {
            DB::transaction(function () use ($request) {
                $exportacaoArquivo =  ExportacaoArquivo::create([
                    'status_id' => Status::AGUARDANDO_PROCESSAMENTO,
                    'competencia' => $request->competencia,
                ]);

                ExportacaoJob::dispatch(app('config')->get('database.default'), $exportacaoArquivo->id);
            });
        } else {
            throw new NaoExisteFichaException();
        }
    }

    public static function destroy($id)
    {
        DB::transaction(function () use ($id) {
            DB::table('atencao_basica_exportacao')
                ->select(['id'])
                ->where('exportacao_arquivo_id', $id)
                ->get()
                ->each(function($query) {
                    AtendimentoIndividual::where('exportacao_id', $query->id)
                        ->update([
                            'exportacao_id' => null,
                            'uuid_ficha' => null,
                            'usuario_exportacao_id' => null,
                            'data_hora_exportacao' => null,
                        ]);

                    Procedimento::where('exportacao_id', $query->id)
                        ->update([
                            'exportacao_id' => null,
                            'uuid_ficha' => null,
                            'usuario_exportacao_id' => null,
                            'data_hora_exportacao' => null,
                        ]);

                    AtendimentoOdontologico::where('exportacao_id', $query->id)
                        ->update([
                            'exportacao_id' => null,
                            'uuid_ficha' => null,
                            'usuario_exportacao_id' => null,
                            'data_exportacao' => null,
                        ]);

                    MarcadorConsumoAlimentar::where('exportacao_id', $query->id)
                        ->update([
                            'exportacao_id' => null,
                            'uuid_ficha' => null,
                            'usuario_exportacao_id' => null,
                            'data_hora_exportacao' => null,
                        ]);

                    AtendimentoDomiciliar::where('exportacao_id', $query->id)
                        ->update([
                            'exportacao_id' => null,
                            'uuid_ficha' => null,
                            'usuario_exportacao_id' => null,
                            'data_exportacao' => null,
                        ]);

                    CadastroIndividual::where('exportacao_id', $query->id)
                        ->update([
                            'exportacao_id' => null,
                            'usuario_exportacao_id' => null,
                            'data_hora_exportacao' => null,
                        ]);

                    CadastroDomiciliar::where('exportacao_id', $query->id)
                        ->update([
                            'exportacao_id' => null,
                            'uuid_ficha' => null,
                            'usuario_exportacao_id' => null,
                            'data_hora_exportacao' => null,
                        ]);

                    FichaComplementar::where('exportacao_id', $query->id)
                        ->update([
                            'exportacao_id' => null,
                            'uuid_ficha' => null,
                            'usuario_exportacao_id' => null,
                            'data_hora_exportacao' => null,
                        ]);

                    Avaliacao::where('exportacao_id', $query->id)
                        ->update([
                            'exportacao_id' => null,
                            'uuid_ficha' => null,
                            'usuario_exportacao_id' => null,
                            'data_hora_exportacao' => null,
                        ]);

                    AtividadeColetiva::where('exportacao_id', $query->id)
                        ->update([
                            'exportacao_id' => null,
                            'uuid_ficha' => null,
                            'usuario_exportacao_id' => null,
                            'data_hora_exportacao' => null,
                        ]);

                    VisitaDomiciliar::where('exportacao_id', $query->id)
                        ->update([
                            'exportacao_id' => null,
                            'uuid_ficha' => null,
                            'usuario_exportacao_id' => null,
                            'data_hora_exportacao' => null,
                        ]);

                    Exportacao::find($query->id)->delete();
                });

            $exportacaoArquivo = ExportacaoArquivo::find($id);

            if (Storage::exists(self::BASE_PATH . app('config')->get('database.default') . DIRECTORY_SEPARATOR . $exportacaoArquivo->arquivo)) {
                Storage::delete(self::BASE_PATH . app('config')->get('database.default') . DIRECTORY_SEPARATOR . $exportacaoArquivo->arquivo);
            }

            $exportacaoArquivo->delete();
        });
    }

    public static function download($id)
    {
        $exportacao = ExportacaoArquivo::where('id', $id)
            ->whereNotNull('arquivo')
            ->whereNull('deleted_at')
            ->first();

        if (!is_null($exportacao)) {
            $cliente = app('config')->get('database.default');
            $file = self::BASE_PATH . $cliente . DIRECTORY_SEPARATOR . $exportacao->arquivo;

            if (Storage::disk('local')->exists($file)) {
                return [
                    'arquivo' => Storage::path($file),
                    'nome' => $exportacao->arquivo,
                ];
            } else {
                throw new ArquivoException();
            }
        } else {
            throw new ArquivoException();
        }
    }

    public static function generate($cliente, $competencia, $exportacaoArquivoId, $usuarioId = null)
    {
        request()->merge(['mes_ano' => $competencia]);

        $path = self::BASE_PATH . $cliente . DIRECTORY_SEPARATOR;
        $fileName = self::getFileName($path, 'exportacaoEsus_' . $cliente . '_' . $competencia . '.zip');

        self::createDirectory($cliente);

        FichaAtendimentoIndividualService::create($path, $fileName, $exportacaoArquivoId, $usuarioId);
        FichaProcedimentoService::create($path, $fileName, $exportacaoArquivoId, $usuarioId);
        FichaAtendimentoOdontologicoService::create($path, $fileName, $exportacaoArquivoId, $usuarioId);
        FichaConsumoAlimentarMenosSeisMesesService::create($path, $fileName, $exportacaoArquivoId, $usuarioId);
        FichaConsumoAlimentarDeSeisAVinteTresMesesService::create($path, $fileName, $exportacaoArquivoId, $usuarioId);
        FichaConsumoAlimentarMaisDoisAnosService::create($path, $fileName, $exportacaoArquivoId, $usuarioId);
        FichaAtendimentoDomiciliarService::create($path, $fileName, $exportacaoArquivoId, $usuarioId);
        FichaCadastroIndividualService::create($path, $fileName, $exportacaoArquivoId, $usuarioId);
        FichaCadastroDomiciliarService::create($path, $fileName, $exportacaoArquivoId, $usuarioId);
        FichaComplementarService::create($path, $fileName, $exportacaoArquivoId, $usuarioId);
        FichaAvaliacaoElegibilidadeService::create($path, $fileName, $exportacaoArquivoId, $usuarioId);
        FichaAtividadeColetivaService::create($path, $fileName, $exportacaoArquivoId, $usuarioId);
        FichaVisitaDomiciliarService::create($path, $fileName, $exportacaoArquivoId, $usuarioId);

        return $fileName;
    }

    public static function gerarExportacoes($mesAnoInicial)
    {
        return [
            'atendimento_individual' => FichaAtendimentoIndividualService::gerarExportacoes($mesAnoInicial),
            'atendimento_domiciliar' => FichaAtendimentoDomiciliarService::gerarExportacoes($mesAnoInicial),
            'atendimento_odontologico' => FichaAtendimentoOdontologicoService::gerarExportacoes($mesAnoInicial),
            'atividade_coletiva' => FichaAtividadeColetivaService::gerarExportacoes($mesAnoInicial),
            'avaliacao' => FichaAvaliacaoElegibilidadeService::gerarExportacoes($mesAnoInicial),
            'procedimento' => FichaProcedimentoService::gerarExportacoes($mesAnoInicial),
            'visita_domiciliar' => FichaVisitaDomiciliarService::gerarExportacoes($mesAnoInicial),
            'ficha_complementar' => FichaComplementarService::gerarExportacoes($mesAnoInicial),
            'cadastro_domiciliar' => FichaCadastroDomiciliarService::gerarExportacoes($mesAnoInicial),
            'cadastro_individual' => FichaCadastroIndividualService::gerarExportacoes($mesAnoInicial),
            'consumo_alimentar' => FichaConsumoAlimentarMenosSeisMesesService::gerarExportacoes($mesAnoInicial)
                ->concat(FichaConsumoAlimentarDeSeisAVinteTresMesesService::gerarExportacoes($mesAnoInicial))
                ->concat(FichaConsumoAlimentarMaisDoisAnosService::gerarExportacoes($mesAnoInicial)),
        ];
    }

    public static function elementVersao($dom, $dadoTransporteTransportXml)
    {
        $versaoData = self::getVersaoIntegradorEsus();

        $versao = $dom->createElement('versao');
        $versao->setAttribute('major', $versaoData['integrador_major']);
        $versao->setAttribute('minor',  $versaoData['integrador_minor']);
        $versao->setAttribute('revision',  $versaoData['integrador_revision']);
        $dadoTransporteTransportXml->appendChild($versao);

        return $versao;
    }

    public static function elementRemetente($dom, $dadoTransporteTransportXml)
    {
        $remetente = $dom->createElement('ns2:remetente');
        $dadoTransporteTransportXml->appendChild($remetente);

        $remetente->appendChild($dom->createElement('contraChave', 'ConectaSUS'));
        $remetente->appendChild($dom->createElement('uuidInstalacao', '625de6ca-c5d6-48aa-85bb-da82cae0da55'));
        $remetente->appendChild($dom->createElement('cpfOuCnpj', '82238529853')); // CPF Sidnei
        $remetente->appendChild($dom->createElement('nomeOuRazaoSocial', 'RKM SISTEMAS LTDA ME'));
        $remetente->appendChild($dom->createElement('fone', '19 3433.7704'));
        $remetente->appendChild($dom->createElement('email', 'analise@rkmsistemas.com.br'));

        return $remetente;
    }

    public static function elementOriginadora($dom, $dadoTransporteTransportXml)
    {
        $originadora = $dom->createElement('ns2:originadora');
        $dadoTransporteTransportXml->appendChild($originadora);

        $originadora->appendChild($dom->createElement('contraChave', 'ConectaSUS'));
        $originadora->appendChild($dom->createElement('uuidInstalacao', '625de6ca-c5d6-48aa-85bb-da82cae0da55'));
        $originadora->appendChild($dom->createElement('cpfOuCnpj', '82238529853')); // CPF Sidnei
        $originadora->appendChild($dom->createElement('nomeOuRazaoSocial', 'RKM SISTEMAS LTDA ME'));
        $originadora->appendChild($dom->createElement('fone', '19 3433.7704'));
        $originadora->appendChild($dom->createElement('email', 'analise@rkmsistemas.com.br'));

        return $originadora;
    }

    public static function getUuid($cnes)
    {
        $uuid = Str::uuid();

        $uuidSemHifens = str_replace('-', '', $uuid);
        $uuidConcatenado = $cnes . $uuidSemHifens;
        $uuidFormatado = substr($uuidConcatenado, 0, 7) . '-' . substr($uuidConcatenado, 7, 4) . '-'
            . substr($uuidConcatenado, 11, 4) . '-' . substr($uuidConcatenado, 15, 4) . '-'
            . substr($uuidConcatenado, 19);

        return $uuidFormatado;
    }

    public static function getFichas()
    {
        $fichas = [];
        $profissional = [];

        if (request()->funcionalidade == 'Atendimento individual') {
            $table = 'atencao_basica_atendimento_individual';
            $dataAtendimento = 'data_usuario_responsavel';
        }
        else if (request()->funcionalidade == 'Cadastro domiciliar e territorial') {
            $table = 'atencao_basica_cadastro_domiciliar';
            $dataAtendimento = 'data_usuario_responsavel';
        }
        else if (request()->funcionalidade == 'Ficha complementar') {
            $table = 'atencao_basica_ficha_complementar';
            $dataAtendimento = 'data_atendimento';
        }
        else if (request()->funcionalidade == 'Avaliação de elegibilidade e admissão') {
            $table = 'atencao_basica_avaliacao';
            $dataAtendimento = 'data';
        }
        else if (request()->funcionalidade == 'Cadastro individual') {
            $table = 'atencao_basica_cadastro_individual';
            $dataAtendimento = 'data_usuario_responsavel';
        }
        else if (request()->funcionalidade == 'Visita domiciliar') {
            $table = 'atencao_basica_visita_domiciliar';
            $dataAtendimento = 'data_usuario_responsavel';
        }
        else if (request()->funcionalidade == 'Atividade coletiva') {
            $table = 'atencao_basica_atividade_coletiva';
            $dataAtendimento = 'data_cadastro';
        }
        else if (request()->funcionalidade == 'Marcador de consumo alimentar') {
            $table = 'atencao_basica_consumo_alimentar';
            $dataAtendimento = 'data_atendimento';
        }
        else if (request()->funcionalidade == 'Atendimento domiciliar') {
            $table = 'atencao_basica_atendimento_domiciliar';
            $dataAtendimento = 'data';
        }
        else if (request()->funcionalidade == 'Atendimento odontológico') {
            $table = 'atencao_basica_atendimento_odontologico';
            $dataAtendimento = 'data_atendimento';
        }

        if (request()->funcionalidade == 'Ficha de vacinação') {
            $vacinacao = self::getFichasVacinacao();
            $fichas = $vacinacao['fichas'];
            $profissional = $vacinacao['profissional'];
        }
        else if (request()->funcionalidade == 'Atendimento domiciliar') {
            $atendimento = self::getFichasAtendimentoDomiciliar();
            $fichas = $atendimento['fichas'];
            $profissional = $atendimento['profissional'];
        }
        else if (request()->funcionalidade == 'Procedimentos') {
            $procedimento = self::getFichasProcedimento();
            $fichas = $procedimento['fichas'];
            $profissional = $procedimento['profissional'];
        }
        else if (request()->funcionalidade == 'Atividade coletiva') {
            $atividade = self::getFichasAtividadeColetiva();
            $fichas = $atividade['fichas'];
            $profissional = $atividade['profissional'];
        }
        else if (request()->funcionalidade == 'Cadastro domiciliar e territorial') {
            $atividade = self::getFichasCadastroDomiciliar();
            $fichas = $atividade['fichas'];
            $profissional = $atividade['profissional'];
        }
        else {
            $fichas = DB::table($table)
                ->select(
                    DB::raw('DATE_FORMAT(' . $table . '.' . $dataAtendimento .', "%d/%m/%Y") as data'),
                    'cidadao.nome as paciente_nome',
                    'cidadao.data_nascimento as paciente_data_nascimento',
                    DB::raw('LPAD(paciente.prontuario,7,0) as paciente_prontuario'),
                    'cidadao.nome_social'
                )
                ->join(
                    'cadastro_paciente as paciente',
                    'paciente.id',
                    $table . '.paciente_id'
                )
                ->join(
                    'cadastro_cidadao as cidadao',
                    'cidadao.id',
                    'paciente.cidadao_id'
                )
                ->where('uuid_ficha', request()->uuid)
                ->get();

            $profissional = self::getProfissional($table);
        }

        return [
            'fichas' => $fichas,
            'profissional' => $profissional,
        ];
    }

    private static function getCompetencias()
    {
        $dataAtual = Carbon::now()->startOfMonth();
        $dataInicial = $dataAtual->copy()->subMonths(6);
        $competencias = [];

        while ($dataAtual >= $dataInicial) {
            $competencias[] = [
                'value' => $dataAtual->format('mY'),
                'text' => ucfirst($dataAtual->translatedFormat('F/Y')),
            ];

            $dataAtual->subMonth();
        }

        return $competencias;
    }

    private static function getCompetenciasFichasExportadas()
    {
        return DB::table('atencao_basica_exportacao_arquivo')
            ->select('competencia')
            ->whereNull('atencao_basica_exportacao_arquivo.deleted_at')
            ->whereRaw("STR_TO_DATE(atencao_basica_exportacao_arquivo.competencia, '%m%Y') >= ?", [Carbon::now()->subYear()->startOfMonth()->toDateString()])
            ->distinct()
            ->get()
            ->map(function ($item) {
                $competencia = Carbon::createFromFormat('mY', $item->competencia);

                return [
                    'value' => $item->competencia,
                    'text' => ucfirst($competencia->translatedFormat('F/Y')),
                ];
            })
            ->sortByDesc(function ($item) {
                return Carbon::createFromFormat('mY', $item['value']);
            })
            ->values();
    }

    private static function getVersaoIntegradorEsus()
    {
        $versao = AtencaoBasicaVersaoIntegradorEsus::latest()->first();

        return [
            'integrador_major' => $versao->integrador_major,
            'integrador_minor' => $versao->integrador_minor,
            'integrador_revision' => $versao->integrador_revision,
            'centralizador_major' => $versao->centralizador_major,
            'centralizador_minor' => $versao->centralizador_minor,
            'centralizador_revision' =>$versao->centralizador_revision,
        ];
    }

    private static function getArquivosExportados()
    {
        return DB::table('atencao_basica_exportacao_arquivo')
            ->select(
                'atencao_basica_exportacao_arquivo.id',
                DB::raw("DATE_FORMAT(atencao_basica_exportacao_arquivo.created_at, '%d/%m/%Y \à\s %H:%i') AS data_hora"),
                'atencao_basica_exportacao_arquivo.competencia',
                'atencao_basica_exportacao_arquivo.arquivo',
                'cadastro_cidadao.nome AS usuario_nome',
                'atencao_basica_exportacao_status.id AS status_id',
                'atencao_basica_exportacao_status.nome AS status_nome',
            )
            ->join('cadastro_lotacao', 'cadastro_lotacao.id', 'atencao_basica_exportacao_arquivo.created_lotacao_id')
            ->join('cadastro_usuario', 'cadastro_usuario.id', 'cadastro_lotacao.usuario_id')
            ->join('cadastro_cidadao', 'cadastro_cidadao.id', 'cadastro_usuario.cidadao_id')
            ->join('atencao_basica_exportacao_status', 'atencao_basica_exportacao_status.id', 'atencao_basica_exportacao_arquivo.status_id')
            ->whereNull('atencao_basica_exportacao_arquivo.deleted_at')
            ->whereRaw("STR_TO_DATE(atencao_basica_exportacao_arquivo.competencia, '%m%Y') >= ?", [Carbon::now()->subYear()->startOfMonth()->toDateString()])
            ->orderByDesc('atencao_basica_exportacao_arquivo.created_at')
            ->get();
    }

    private static function hasExportacaoEmAndamento()
    {
        return ExportacaoArquivo::whereIn('status_id', [
            Status::AGUARDANDO_PROCESSAMENTO,
            Status::EM_PROCESSAMENTO,
        ])->exists();
    }

    private static function hasFichasParaExportacao($competencia)
    {
        $atendimentoIndividual = DB::table('atencao_basica_atendimento_individual')
            ->whereNull('exportacao_id')
            ->whereYear('data_usuario_responsavel', substr($competencia, 2))
            ->whereMonth('data_usuario_responsavel', substr($competencia, 0, 2))
            ->exists();

        if ($atendimentoIndividual) {
            return $atendimentoIndividual;
        }

        $procedimento = DB::table('atencao_basica_procedimento')
            ->whereNull('exportacao_id')
            ->whereYear('data_usuario_responsavel', substr($competencia, 2))
            ->whereMonth('data_usuario_responsavel', substr($competencia, 0, 2))
            ->exists();

        if ($procedimento) {
            return $procedimento;
        }

        $atendimentoOdontologico = DB::table('atencao_basica_atendimento_odontologico')
            ->whereNull('exportacao_id')
            ->whereYear('data_atendimento', substr($competencia, 2))
            ->whereMonth('data_atendimento', substr($competencia, 0, 2))
            ->exists();

        if ($atendimentoOdontologico) {
            return $atendimentoOdontologico;
        }

        $marcadorConsumoAlimentar = DB::table('atencao_basica_consumo_alimentar')
            ->whereNull('exportacao_id')
            ->whereYear('data_atendimento', substr($competencia, 2))
            ->whereMonth('data_atendimento', substr($competencia, 0, 2))
            ->exists();

        if ($marcadorConsumoAlimentar) {
            return $marcadorConsumoAlimentar;
        }

        $atendimentoDomiciliar = DB::table('atencao_basica_atendimento_domiciliar')
            ->whereNull('exportacao_id')
            ->whereYear('data', substr($competencia, 2))
            ->whereMonth('data', substr($competencia, 0, 2))
            ->exists();

        if ($atendimentoDomiciliar) {
            return $atendimentoDomiciliar;
        }

        $cadastroIndividual = DB::table('atencao_basica_cadastro_individual')
            ->whereNull('exportacao_id')
            ->whereYear('data_usuario_responsavel', substr($competencia, 2))
            ->whereMonth('data_usuario_responsavel', substr($competencia, 0, 2))
            ->exists();

        if ($cadastroIndividual) {
            return $cadastroIndividual;
        }

        $cadastroDomiciliar = DB::table('atencao_basica_cadastro_domiciliar')
            ->whereNull('exportacao_id')
            ->whereYear('data_usuario_responsavel', substr($competencia, 2))
            ->whereMonth('data_usuario_responsavel', substr($competencia, 0, 2))
            ->exists();

        if ($cadastroDomiciliar) {
            return $cadastroDomiciliar;
        }

        $fichaComplementar = DB::table('atencao_basica_ficha_complementar')
            ->whereNull('exportacao_id')
            ->whereYear('data_atendimento', substr($competencia, 2))
            ->whereMonth('data_atendimento', substr($competencia, 0, 2))
            ->exists();

        if ($fichaComplementar) {
            return $fichaComplementar;
        }

        $avaliacao = DB::table('atencao_basica_avaliacao')
            ->whereNull('exportacao_id')
            ->whereYear('data', substr($competencia, 2))
            ->whereMonth('data', substr($competencia, 0, 2))
            ->exists();

        if ($avaliacao) {
            return $avaliacao;
        }

        $atividadeColetiva = DB::table('atencao_basica_atividade_coletiva')
            ->whereNull('exportacao_id')
            ->whereYear('data_usuario_responsavel', substr($competencia, 2))
            ->whereMonth('data_usuario_responsavel', substr($competencia, 0, 2))
            ->exists();

        if ($atividadeColetiva) {
            return $atividadeColetiva;
        }

        $visitaDomiciliar = DB::table('atencao_basica_visita_domiciliar')
            ->whereNull('exportacao_id')
            ->whereYear('data_usuario_responsavel', substr($competencia, 2))
            ->whereMonth('data_usuario_responsavel', substr($competencia, 0, 2))
            ->exists();

        if ($visitaDomiciliar) {
            return $visitaDomiciliar;
        }
    }

    private static function getFichasExportadas($request)
    {
        return DB::table('atencao_basica_exportacao')
            ->select(
                'atencao_basica_exportacao.uuid AS uuid',
                'cadastro_cidadao.nome as usuario',
                DB::raw("DATE_FORMAT(atencao_basica_exportacao.created_at, '%d/%m/%Y') AS data"),
                DB::raw("DATE_FORMAT(atencao_basica_exportacao.created_at, '%H:%i') AS horario"),
                DB::raw("
                    DATE_FORMAT(
                        CASE
                            WHEN EXISTS (SELECT 1 FROM atencao_basica_atendimento_domiciliar
                                        WHERE exportacao_id = atencao_basica_exportacao.id)
                                THEN (SELECT data
                                    FROM atencao_basica_atendimento_domiciliar
                                    WHERE exportacao_id = atencao_basica_exportacao.id
                                    ORDER BY data ASC LIMIT 1)
                            WHEN EXISTS (SELECT 1 FROM atencao_basica_atendimento_individual
                                        WHERE exportacao_id = atencao_basica_exportacao.id)
                                THEN (SELECT data_usuario_responsavel
                                    FROM atencao_basica_atendimento_individual
                                    WHERE exportacao_id = atencao_basica_exportacao.id
                                    ORDER BY data_usuario_responsavel ASC LIMIT 1)
                            WHEN EXISTS (SELECT 1 FROM atencao_basica_atendimento_odontologico
                                        WHERE exportacao_id = atencao_basica_exportacao.id)
                                THEN (SELECT data_atendimento
                                    FROM atencao_basica_atendimento_odontologico
                                    WHERE exportacao_id = atencao_basica_exportacao.id
                                    ORDER BY data_atendimento ASC LIMIT 1)
                            WHEN EXISTS (SELECT 1 FROM atencao_basica_atividade_coletiva
                                        WHERE exportacao_id = atencao_basica_exportacao.id)
                                THEN (SELECT data_usuario_responsavel
                                    FROM atencao_basica_atividade_coletiva
                                    WHERE exportacao_id = atencao_basica_exportacao.id
                                    ORDER BY data_usuario_responsavel ASC LIMIT 1)
                            WHEN EXISTS (SELECT 1 FROM atencao_basica_avaliacao
                                        WHERE exportacao_id = atencao_basica_exportacao.id)
                                THEN (SELECT data
                                    FROM atencao_basica_avaliacao
                                    WHERE exportacao_id = atencao_basica_exportacao.id
                                    ORDER BY data ASC LIMIT 1)
                            WHEN EXISTS (SELECT 1 FROM atencao_basica_cadastro_domiciliar
                                        WHERE exportacao_id = atencao_basica_exportacao.id)
                                THEN (SELECT data_usuario_responsavel
                                    FROM atencao_basica_cadastro_domiciliar
                                    WHERE exportacao_id = atencao_basica_exportacao.id
                                    ORDER BY data_usuario_responsavel ASC LIMIT 1)
                            WHEN EXISTS (SELECT 1 FROM atencao_basica_cadastro_individual
                                        WHERE exportacao_id = atencao_basica_exportacao.id)
                                THEN (SELECT data_usuario_responsavel
                                    FROM atencao_basica_cadastro_individual
                                    WHERE exportacao_id = atencao_basica_exportacao.id
                                    ORDER BY data_usuario_responsavel ASC LIMIT 1)
                            WHEN EXISTS (SELECT 1 FROM atencao_basica_ficha_complementar
                                        WHERE exportacao_id = atencao_basica_exportacao.id)
                                THEN (SELECT data_atendimento
                                    FROM atencao_basica_ficha_complementar
                                    WHERE exportacao_id = atencao_basica_exportacao.id
                                    ORDER BY data_atendimento ASC LIMIT 1)
                            WHEN EXISTS (SELECT 1 FROM atencao_basica_ficha_vacinacao
                                        WHERE exportacao_id = atencao_basica_exportacao.id)
                                THEN (SELECT data_atendimento
                                    FROM atencao_basica_ficha_vacinacao
                                    WHERE exportacao_id = atencao_basica_exportacao.id
                                    ORDER BY data_atendimento ASC LIMIT 1)
                            WHEN EXISTS (SELECT 1 FROM atencao_basica_consumo_alimentar
                                        WHERE exportacao_id = atencao_basica_exportacao.id)
                                THEN (SELECT data_atendimento
                                    FROM atencao_basica_consumo_alimentar
                                    WHERE exportacao_id = atencao_basica_exportacao.id
                                    ORDER BY data_atendimento ASC LIMIT 1)
                            WHEN EXISTS (SELECT 1 FROM atencao_basica_procedimento
                                        WHERE exportacao_id = atencao_basica_exportacao.id)
                                THEN (SELECT data_usuario_responsavel
                                    FROM atencao_basica_procedimento
                                    WHERE exportacao_id = atencao_basica_exportacao.id
                                    ORDER BY data_usuario_responsavel ASC LIMIT 1)
                            WHEN EXISTS (SELECT 1 FROM atencao_basica_visita_domiciliar
                                        WHERE exportacao_id = atencao_basica_exportacao.id)
                                THEN (SELECT data_usuario_responsavel
                                    FROM atencao_basica_visita_domiciliar
                                    WHERE exportacao_id = atencao_basica_exportacao.id
                                    ORDER BY data_usuario_responsavel ASC LIMIT 1)
                            ELSE atencao_basica_exportacao.created_at
                        END,
                    '%d/%m/%Y') AS data_ficha
                ")
            )
            ->addSelect(self::getFuncionalidade())
            ->addSelect(self::getQuantidade())
            ->leftJoin('cadastro_lotacao', 'cadastro_lotacao.id', 'atencao_basica_exportacao.created_lotacao_id')
            ->leftJoin('cadastro_usuario', 'cadastro_usuario.id', 'cadastro_lotacao.usuario_id')
            ->join('cadastro_cidadao', 'cadastro_cidadao.id', 'cadastro_usuario.cidadao_id')
            ->where(fn ($q) => $q
                ->whereExists(fn ($q) => $q
                    ->select(DB::raw(1))
                    ->from('atencao_basica_atendimento_domiciliar')
                    ->whereColumn('atencao_basica_atendimento_domiciliar.exportacao_id', 'atencao_basica_exportacao.id')
                    ->whereYear('atencao_basica_atendimento_domiciliar.data', substr($request->competencia_ficha_exportada, 2))
                    ->whereMonth('atencao_basica_atendimento_domiciliar.data', substr($request->competencia_ficha_exportada, 0, 2))
                )
                ->orWhereExists(fn ($q) => $q
                    ->select(DB::raw(1))
                    ->from('atencao_basica_atendimento_individual')
                    ->whereColumn('atencao_basica_atendimento_individual.exportacao_id', 'atencao_basica_exportacao.id')
                    ->whereYear('atencao_basica_atendimento_individual.data_usuario_responsavel', substr($request->competencia_ficha_exportada, 2))
                    ->whereMonth('atencao_basica_atendimento_individual.data_usuario_responsavel', substr($request->competencia_ficha_exportada, 0, 2))
                )
                ->orWhereExists(fn ($q) => $q
                    ->select(DB::raw(1))
                    ->from('atencao_basica_atendimento_odontologico')
                    ->whereColumn('atencao_basica_atendimento_odontologico.exportacao_id', 'atencao_basica_exportacao.id')
                    ->whereYear('atencao_basica_atendimento_odontologico.data_atendimento', substr($request->competencia_ficha_exportada, 2))
                    ->whereMonth('atencao_basica_atendimento_odontologico.data_atendimento', substr($request->competencia_ficha_exportada, 0, 2))
                )
                ->orWhereExists(fn ($q) => $q
                    ->select(DB::raw(1))
                    ->from('atencao_basica_atividade_coletiva')
                    ->whereColumn('atencao_basica_atividade_coletiva.exportacao_id', 'atencao_basica_exportacao.id')
                    ->whereYear('atencao_basica_atividade_coletiva.data_usuario_responsavel', substr($request->competencia_ficha_exportada, 2))
                    ->whereMonth('atencao_basica_atividade_coletiva.data_usuario_responsavel', substr($request->competencia_ficha_exportada, 0, 2))
                )
                ->orWhereExists(fn ($q) => $q
                    ->select(DB::raw(1))
                    ->from('atencao_basica_avaliacao')
                    ->whereColumn('atencao_basica_avaliacao.exportacao_id', 'atencao_basica_exportacao.id')
                    ->whereYear('atencao_basica_avaliacao.data', substr($request->competencia_ficha_exportada, 2))
                    ->whereMonth('atencao_basica_avaliacao.data', substr($request->competencia_ficha_exportada, 0, 2))
                )
                ->orWhereExists(fn ($q) => $q
                    ->select(DB::raw(1))
                    ->from('atencao_basica_cadastro_domiciliar')
                    ->whereColumn('atencao_basica_cadastro_domiciliar.exportacao_id', 'atencao_basica_exportacao.id')
                    ->whereYear('atencao_basica_cadastro_domiciliar.data_usuario_responsavel', substr($request->competencia_ficha_exportada, 2))
                    ->whereMonth('atencao_basica_cadastro_domiciliar.data_usuario_responsavel', substr($request->competencia_ficha_exportada, 0, 2))
                )
                ->orWhereExists(fn ($q) => $q
                    ->select(DB::raw(1))
                    ->from('atencao_basica_cadastro_individual')
                    ->whereColumn('atencao_basica_cadastro_individual.exportacao_id', 'atencao_basica_exportacao.id')
                    ->whereYear('atencao_basica_cadastro_individual.data_usuario_responsavel', substr($request->competencia_ficha_exportada, 2))
                    ->whereMonth('atencao_basica_cadastro_individual.data_usuario_responsavel', substr($request->competencia_ficha_exportada, 0, 2))
                )
                ->orWhereExists(fn ($q) => $q
                    ->select(DB::raw(1))
                    ->from('atencao_basica_ficha_complementar')
                    ->whereColumn('atencao_basica_ficha_complementar.exportacao_id', 'atencao_basica_exportacao.id')
                    ->whereYear('atencao_basica_ficha_complementar.data_atendimento', substr($request->competencia_ficha_exportada, 2))
                    ->whereMonth('atencao_basica_ficha_complementar.data_atendimento', substr($request->competencia_ficha_exportada, 0, 2))
                )
                ->orWhereExists(fn ($q) => $q
                    ->select(DB::raw(1))
                    ->from('atencao_basica_ficha_vacinacao')
                    ->whereColumn('atencao_basica_ficha_vacinacao.exportacao_id', 'atencao_basica_exportacao.id')
                    ->whereYear('atencao_basica_ficha_vacinacao.data_atendimento', substr($request->competencia_ficha_exportada, 2))
                    ->whereMonth('atencao_basica_ficha_vacinacao.data_atendimento', substr($request->competencia_ficha_exportada, 0, 2))
                )
                ->orWhereExists(fn ($q) => $q
                    ->select(DB::raw(1))
                    ->from('atencao_basica_consumo_alimentar')
                    ->whereColumn('atencao_basica_consumo_alimentar.exportacao_id', 'atencao_basica_exportacao.id')
                    ->whereYear('atencao_basica_consumo_alimentar.data_atendimento', substr($request->competencia_ficha_exportada, 2))
                    ->whereMonth('atencao_basica_consumo_alimentar.data_atendimento', substr($request->competencia_ficha_exportada, 0, 2))
                )
                ->orWhereExists(fn ($q) => $q
                    ->select(DB::raw(1))
                    ->from('atencao_basica_procedimento')
                    ->whereColumn('atencao_basica_procedimento.exportacao_id', 'atencao_basica_exportacao.id')
                    ->whereYear('atencao_basica_procedimento.data_usuario_responsavel', substr($request->competencia_ficha_exportada, 2))
                    ->whereMonth('atencao_basica_procedimento.data_usuario_responsavel', substr($request->competencia_ficha_exportada, 0, 2))
                )
                ->orWhereExists(fn ($q) => $q
                    ->select(DB::raw(1))
                    ->from('atencao_basica_visita_domiciliar')
                    ->whereColumn('atencao_basica_visita_domiciliar.exportacao_id', 'atencao_basica_exportacao.id')
                    ->whereYear('atencao_basica_visita_domiciliar.data_usuario_responsavel', substr($request->competencia_ficha_exportada, 2))
                    ->whereMonth('atencao_basica_visita_domiciliar.data_usuario_responsavel', substr($request->competencia_ficha_exportada, 0, 2))
                )
            )
            ->get();
    }

    private static function getProfissional($table)
    {
        return DB::table($table)
            ->select(
                'cadastro_cidadao.nome as nome',
                DB::raw("CONCAT(TRIM(cadastro_unidade.cnes), ' - ', cadastro_unidade.nome_fantasia) AS unidade"),
                DB::raw('COALESCE(cadastro_infraestrutura.nome, cadastro_unidade.nome_fantasia) AS local_atendimento'),
                DB::raw("CONCAT(
                    'INE: ', atencao_basica_parametrizacao_area.numero_ine,
                    CASE
                        WHEN atencao_basica_parametrizacao_area.descricao IS NOT NULL
                        THEN CONCAT(' - Área: ', atencao_basica_parametrizacao_area.descricao)
                        ELSE ''
                    END,
                    ' - Microárea: ', atencao_basica_parametrizacao_microarea.descricao
                ) AS equipe_descricao")
            )
            ->join(
                'atencao_basica_parametrizacao_equipe',
                'atencao_basica_parametrizacao_equipe.id',
                $table . '.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'
            )
            ->join(
                'cadastro_usuario',
                'cadastro_usuario.id',
                $table . '.usuario_id'
            )
            ->join(
                'cadastro_cidadao',
                'cadastro_cidadao.id',
                'cadastro_usuario.cidadao_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('uuid_ficha', request()->uuid)
            ->first();
    }

    private static function getFichasVacinacao()
    {
        $fichas = DB::table('atencao_basica_vacinacao_paciente')
            ->select(
                DB::raw('DATE_FORMAT(vacinacao.data_atendimento, "%d/%m/%Y") as data'),
                'cidadao.nome as paciente_nome',
                'cidadao.data_nascimento as paciente_data_nascimento',
                DB::raw('LPAD(paciente.prontuario,7,0) as paciente_prontuario'),
                'cidadao.nome_social',
            )
            ->join('cadastro_paciente as paciente', 'paciente.id', 'atencao_basica_vacinacao_paciente.paciente_id')
            ->join('cadastro_cidadao as cidadao', 'cidadao.id', 'paciente.cidadao_id')
            ->join('atencao_basica_ficha_vacinacao as vacinacao', 'vacinacao.id', 'atencao_basica_vacinacao_paciente.vacinacao_id')
            ->whereExists(function ($query) {
                $query->select(DB::raw(1))
                    ->from('atencao_basica_vacinacao_paciente_item')
                    ->whereColumn('vacinacao_paciente_id', 'atencao_basica_vacinacao_paciente.id');
            })
            ->where('uuid_ficha', request()->uuid)
            ->get();

        $profissional = self::getProfissional('atencao_basica_ficha_vacinacao');

        return [
            'fichas' => $fichas,
            'profissional' => $profissional,
        ];
    }

    private static function getFichasAtendimentoDomiciliar()
    {
        $fichas = DB::table('atencao_basica_atendimento_domiciliar_atendimento')
            ->select(
                DB::raw('DATE_FORMAT(atencao_basica_atendimento_domiciliar.data, "%d/%m/%Y") as data'),
                'cidadao.nome as paciente_nome',
                'cidadao.data_nascimento as paciente_data_nascimento',
                DB::raw('LPAD(paciente.prontuario,7,0) as paciente_prontuario'),
                'cidadao.nome_social',
            )
            ->join('cadastro_paciente as paciente', 'paciente.id', 'atencao_basica_atendimento_domiciliar_atendimento.paciente_id')
            ->join('cadastro_cidadao as cidadao', 'cidadao.id', 'paciente.cidadao_id')
            ->join('atencao_basica_atendimento_domiciliar', 'atencao_basica_atendimento_domiciliar.id', 'atencao_basica_atendimento_domiciliar_atendimento.atendimento_domiciliar_id')
            ->where('uuid_ficha', request()->uuid)
            ->get();

        $profissional = self::getProfissional('atencao_basica_atendimento_domiciliar');

        return [
            'fichas' => $fichas,
            'profissional' => $profissional,
        ];
    }

    private static function getFichasProcedimento()
    {
        $fichas = DB::table('atencao_basica_procedimento_atendimento')
            ->select(
                DB::raw('DATE_FORMAT(atencao_basica_procedimento.data_usuario_responsavel, "%d/%m/%Y") as data'),
                'cidadao.nome as paciente_nome',
                'cidadao.data_nascimento as paciente_data_nascimento',
                DB::raw('LPAD(paciente.prontuario,7,0) as paciente_prontuario'),
                'cidadao.nome_social',
            )
            ->join('cadastro_paciente as paciente', 'paciente.id', 'atencao_basica_procedimento_atendimento.paciente_id')
            ->join('cadastro_cidadao as cidadao', 'cidadao.id', 'paciente.cidadao_id')
            ->join('atencao_basica_procedimento', 'atencao_basica_procedimento.id', 'atencao_basica_procedimento_atendimento.procedimento_id')
            ->where('uuid_ficha', request()->uuid)
            ->get();

        $profissional = self::getProfissional('atencao_basica_procedimento');

        return [
            'fichas' => $fichas,
            'profissional' => $profissional,
        ];
    }

    private static function getFichasAtividadeColetiva()
    {
        $fichas = DB::table('atencao_basica_atividade_coletiva')
            ->select([
                DB::raw('DATE_FORMAT(atencao_basica_atividade_coletiva.data_cadastro, "%d/%m/%Y") as data'),
                'atencao_basica_atividade_coletiva.total_participantes',
                'atividade_tipo.descricao AS atividade_tipo',
                DB::raw('CASE WHEN cadastro_cidadao.nome_social IS NOT NULL THEN cadastro_cidadao.nome_social ELSE cadastro_cidadao.nome END AS profissional_responsavel'),
                DB::raw('CASE WHEN inep IS NOT NULL THEN inep WHEN local_atividade IS NOT NULL THEN local_atividade ELSE cnes END AS local_atividade'),
                DB::raw('GROUP_CONCAT(saude_temas.descricao SEPARATOR ", ") AS saude_temas'),
            ])
            ->leftJoin('cadastro_usuario', 'cadastro_usuario.id', 'atencao_basica_atividade_coletiva.usuario_id')
            ->leftJoin('cadastro_cidadao', 'cadastro_cidadao.id', 'cadastro_usuario.cidadao_id')
            ->leftJoin('atencao_basica_cadastro_atividade_tipo AS atividade_tipo', 'atividade_tipo.id', 'atencao_basica_atividade_coletiva.atividade_tipo_id')
            ->leftJoin('atencao_basica_atividade_coletiva_saude_tema AS tema', 'tema.atividade_coletiva_id', 'atencao_basica_atividade_coletiva.id')
            ->leftJoin('atencao_basica_cadastro_saude_tema AS saude_temas', 'saude_temas.id', 'tema.saude_tema_id')
            ->where('uuid_ficha', request()->uuid)
            ->get();

        $profissional = self::getProfissional('atencao_basica_atividade_coletiva');

        return [
            'fichas' => $fichas,
            'profissional' => $profissional,
        ];
    }

    private static function getFichasCadastroDomiciliar()
    {
        $fichas = DB::table('atencao_basica_cadastro_domiciliar')
            ->select([
                DB::raw('DATE_FORMAT(atencao_basica_cadastro_domiciliar.data_usuario_responsavel, "%d/%m/%Y") as data'),
                'cadastro_logradouro.nome AS logradouro_nome',
                'cadastro_logradouro_tipo.descricao AS logradouro_tipo_descricao',
                'cadastro_bairro.nome AS bairro',
                DB::raw("COALESCE(cadastro_endereco.complemento, '-') AS endereco_complemento"),
                DB::raw("COALESCE(cadastro_endereco.numero, '-') AS endereco_numero"),
                DB::raw("COALESCE(cadastro_loteamento.nome, '-') AS loteamento_nome"),
                DB::raw("CONCAT(
                    SUBSTR(cadastro_logradouro.cep,1,2),
                    '.',
                    SUBSTR(cadastro_logradouro.cep,3,3),
                    '-',
                    SUBSTR(cadastro_logradouro.cep,6,3)) AS logradouro_cep"
                ),
            ])
            ->join('cadastro_domicilio', 'cadastro_domicilio.id', 'atencao_basica_cadastro_domiciliar.domicilio_id')
            ->join('cadastro_endereco', 'cadastro_endereco.id', 'cadastro_domicilio.endereco_id')
            ->join('cadastro_logradouro', 'cadastro_logradouro.id', 'cadastro_endereco.logradouro_id')
            ->join('cadastro_logradouro_tipo', 'cadastro_logradouro_tipo.id', 'cadastro_logradouro.tipo_id')
            ->join('cadastro_bairro', 'cadastro_bairro.id', 'cadastro_logradouro.bairro_id')
            ->leftJoin('cadastro_loteamento', 'cadastro_loteamento.id', 'cadastro_endereco.loteamento_id')
            ->where('uuid_ficha', request()->uuid)
            ->get();

        $profissional = self::getProfissional('atencao_basica_cadastro_domiciliar');

        return [
            'fichas' => $fichas,
            'profissional' => $profissional,
        ];
    }

    private static function getQuantidade()
    {
        return DB::raw("
            CASE
                WHEN EXISTS (
                    SELECT 1
                    FROM atencao_basica_atendimento_domiciliar
                    WHERE atencao_basica_atendimento_domiciliar.exportacao_id = atencao_basica_exportacao.id
                ) THEN (
                    SELECT COUNT(*)
                    FROM atencao_basica_atendimento_domiciliar_atendimento
                    INNER JOIN atencao_basica_atendimento_domiciliar
                        ON atencao_basica_atendimento_domiciliar.id = atencao_basica_atendimento_domiciliar_atendimento.atendimento_domiciliar_id
                    WHERE atencao_basica_atendimento_domiciliar.exportacao_id = atencao_basica_exportacao.id
                )
                WHEN EXISTS (
                    SELECT 1
                    FROM atencao_basica_atendimento_individual
                    WHERE atencao_basica_atendimento_individual.exportacao_id = atencao_basica_exportacao.id
                ) THEN (
                    SELECT COUNT(*)
                    FROM atencao_basica_atendimento_individual
                    WHERE atencao_basica_atendimento_individual.exportacao_id = atencao_basica_exportacao.id
                )
                WHEN EXISTS (
                    SELECT 1
                    FROM atencao_basica_atendimento_odontologico
                    WHERE atencao_basica_atendimento_odontologico.exportacao_id = atencao_basica_exportacao.id
                ) THEN (
                    SELECT COUNT(*)
                    FROM atencao_basica_atendimento_odontologico
                    WHERE atencao_basica_atendimento_odontologico.exportacao_id = atencao_basica_exportacao.id
                )
                WHEN EXISTS (
                    SELECT 1
                    FROM atencao_basica_atividade_coletiva
                    WHERE atencao_basica_atividade_coletiva.exportacao_id = atencao_basica_exportacao.id
                ) THEN (
                    SELECT COUNT(*)
                    FROM atencao_basica_atividade_coletiva
                    WHERE atencao_basica_atividade_coletiva.exportacao_id = atencao_basica_exportacao.id
                )
                WHEN EXISTS (
                    SELECT 1
                    FROM atencao_basica_avaliacao
                    WHERE atencao_basica_avaliacao.exportacao_id = atencao_basica_exportacao.id
                ) THEN (
                    SELECT COUNT(*)
                    FROM atencao_basica_avaliacao
                    WHERE atencao_basica_avaliacao.exportacao_id = atencao_basica_exportacao.id
                )
                WHEN EXISTS (
                    SELECT 1
                    FROM atencao_basica_cadastro_domiciliar
                    WHERE atencao_basica_cadastro_domiciliar.exportacao_id = atencao_basica_exportacao.id
                ) THEN (
                    SELECT COUNT(*)
                    FROM atencao_basica_cadastro_domiciliar
                    WHERE atencao_basica_cadastro_domiciliar.exportacao_id = atencao_basica_exportacao.id
                )
                WHEN EXISTS (
                    SELECT 1
                    FROM atencao_basica_cadastro_individual
                    WHERE atencao_basica_cadastro_individual.exportacao_id = atencao_basica_exportacao.id
                ) THEN (
                    SELECT COUNT(*)
                    FROM atencao_basica_cadastro_individual
                    WHERE atencao_basica_cadastro_individual.exportacao_id = atencao_basica_exportacao.id
                )
                WHEN EXISTS (
                    SELECT 1
                    FROM atencao_basica_ficha_complementar
                    WHERE atencao_basica_ficha_complementar.exportacao_id = atencao_basica_exportacao.id
                ) THEN (
                    SELECT COUNT(*)
                    FROM atencao_basica_ficha_complementar
                    WHERE atencao_basica_ficha_complementar.exportacao_id = atencao_basica_exportacao.id
                )
                WHEN EXISTS (
                    SELECT 1
                    FROM atencao_basica_ficha_vacinacao
                    WHERE atencao_basica_ficha_vacinacao.exportacao_id = atencao_basica_exportacao.id
                ) THEN (
                    SELECT COUNT(*)
                    FROM atencao_basica_vacinacao_paciente
                    INNER JOIN atencao_basica_ficha_vacinacao
                        ON atencao_basica_ficha_vacinacao.id = atencao_basica_vacinacao_paciente.vacinacao_id
                    INNER JOIN atencao_basica_vacinacao_paciente_item
                        ON atencao_basica_vacinacao_paciente_item.vacinacao_paciente_id = atencao_basica_vacinacao_paciente.id
                    WHERE atencao_basica_ficha_vacinacao.exportacao_id = atencao_basica_exportacao.id
                )
                WHEN EXISTS (
                    SELECT 1
                    FROM atencao_basica_consumo_alimentar
                    WHERE atencao_basica_consumo_alimentar.exportacao_id = atencao_basica_exportacao.id
                ) THEN (
                    SELECT COUNT(*)
                    FROM atencao_basica_consumo_alimentar
                    WHERE atencao_basica_consumo_alimentar.exportacao_id = atencao_basica_exportacao.id
                )
                WHEN EXISTS (
                    SELECT 1
                    FROM atencao_basica_procedimento
                    WHERE atencao_basica_procedimento.exportacao_id = atencao_basica_exportacao.id
                ) THEN (
                    SELECT COUNT(*)
                    FROM atencao_basica_procedimento_atendimento
                    INNER JOIN atencao_basica_procedimento
                        ON atencao_basica_procedimento.id = atencao_basica_procedimento_atendimento.procedimento_id
                    WHERE atencao_basica_procedimento.exportacao_id = atencao_basica_exportacao.id
                )
                WHEN EXISTS (
                    SELECT 1
                    FROM atencao_basica_visita_domiciliar
                    WHERE atencao_basica_visita_domiciliar.exportacao_id = atencao_basica_exportacao.id
                ) THEN (
                    SELECT COUNT(*)
                    FROM atencao_basica_visita_domiciliar
                    WHERE atencao_basica_visita_domiciliar.exportacao_id = atencao_basica_exportacao.id
                )
                ELSE 0
            END AS quantidade
        ");
    }

    private static function getFuncionalidade()
    {
        return DB::raw("
            CASE
                WHEN (
                    SELECT 1 FROM atencao_basica_atendimento_domiciliar
                    WHERE atencao_basica_atendimento_domiciliar.exportacao_id = atencao_basica_exportacao.id
                    LIMIT 1
                ) IS NOT NULL THEN 'Atendimento domiciliar'
                WHEN (
                    SELECT 1 FROM atencao_basica_atendimento_individual
                    WHERE atencao_basica_atendimento_individual.exportacao_id = atencao_basica_exportacao.id
                    LIMIT 1
                ) IS NOT NULL THEN 'Atendimento individual'
                WHEN (
                    SELECT 1 FROM atencao_basica_atendimento_odontologico
                    WHERE atencao_basica_atendimento_odontologico.exportacao_id = atencao_basica_exportacao.id
                    LIMIT 1
                ) IS NOT NULL THEN 'Atendimento odontológico'
                WHEN (
                    SELECT 1 FROM atencao_basica_atividade_coletiva
                    WHERE atencao_basica_atividade_coletiva.exportacao_id = atencao_basica_exportacao.id
                    LIMIT 1
                ) IS NOT NULL THEN 'Atividade coletiva'
                WHEN (
                    SELECT 1 FROM atencao_basica_avaliacao
                    WHERE atencao_basica_avaliacao.exportacao_id = atencao_basica_exportacao.id
                    LIMIT 1
                ) IS NOT NULL THEN 'Avaliação de elegibilidade e admissão'
                WHEN (
                    SELECT 1 FROM atencao_basica_cadastro_domiciliar
                    WHERE atencao_basica_cadastro_domiciliar.exportacao_id = atencao_basica_exportacao.id
                    LIMIT 1
                ) IS NOT NULL THEN 'Cadastro domiciliar e territorial'
                WHEN (
                    SELECT 1 FROM atencao_basica_cadastro_individual
                    WHERE atencao_basica_cadastro_individual.exportacao_id = atencao_basica_exportacao.id
                    LIMIT 1
                ) IS NOT NULL THEN 'Cadastro individual'
                WHEN (
                    SELECT 1 FROM atencao_basica_ficha_complementar
                    WHERE atencao_basica_ficha_complementar.exportacao_id = atencao_basica_exportacao.id
                    LIMIT 1
                ) IS NOT NULL THEN 'Ficha complementar'
                WHEN (
                    SELECT 1 FROM atencao_basica_ficha_vacinacao
                    WHERE atencao_basica_ficha_vacinacao.exportacao_id = atencao_basica_exportacao.id
                    LIMIT 1
                ) IS NOT NULL THEN 'Ficha de vacinação'
                WHEN (
                    SELECT 1 FROM atencao_basica_consumo_alimentar
                    WHERE atencao_basica_consumo_alimentar.exportacao_id = atencao_basica_exportacao.id
                    LIMIT 1
                ) IS NOT NULL THEN 'Marcador de consumo alimentar'
                WHEN (
                    SELECT 1 FROM atencao_basica_procedimento
                    WHERE atencao_basica_procedimento.exportacao_id = atencao_basica_exportacao.id
                    LIMIT 1
                ) IS NOT NULL THEN 'Procedimentos'
                WHEN (
                    SELECT 1 FROM atencao_basica_visita_domiciliar
                    WHERE atencao_basica_visita_domiciliar.exportacao_id = atencao_basica_exportacao.id
                    LIMIT 1
                ) IS NOT NULL THEN 'Visita domiciliar'
                ELSE '-'
            END AS funcionalidade
        ");
    }

    private static function getFileName($path, $fileName, $counter = 0)
    {
        $sufixo = ($counter > 0) ? '_' . $counter : '';

        $newFileName = pathinfo($fileName, PATHINFO_FILENAME) . $sufixo . '.' . pathinfo($fileName, PATHINFO_EXTENSION);
        $newPath = Storage::path($path . $newFileName);

        if (File::exists($newPath)) {
            return self::getFileName($path, $fileName, $counter + 1);
        }

        return $newFileName;
    }

    private static function createDirectory($cliente)
    {
        $path = Storage::path(self::BASE_PATH . $cliente);

        if (file_exists($path) === false) {
            File::makeDirectory($path, 0775, true, true);
            chmod($path, 0775);
        }
    }

    private static function validate($request)
    {
        $request->validate([
            'competencia' => [
                'required',
                'string',
            ],
        ]);
    }
}