<?php

namespace App\Services\Bpa;

use App\Enums\AtencaoBasica\CadastroDomiciliar\CadastroDomicilioTipo;
use App\Enums\Bpa\ExportacaoStatus;
use App\Enums\Bpa\Inconsistencia;
use App\Enums\Sigtap\Registro;
use App\Exceptions\Bpa\ExportacaoEmAndamentoException;
use App\Jobs\Bpa\ExportacaoJob;
use App\Models\Bpa\Exportacao;
use App\Models\Bpa\Procedimento;
use App\Rules\Bpa\BairroIsRequired;
use App\Rules\Bpa\CaraterAtendimentoExists;
use App\Rules\Bpa\CepIsValid;
use App\Rules\Bpa\CnesIsValid;
use App\Rules\Bpa\DataAtendimentoIsValid;
use App\Rules\Bpa\EtniaIndigenaIsValid;
use App\Rules\Bpa\IdadeIsRequired;
use App\Rules\Bpa\LogradouroIsRequired;
use App\Rules\Bpa\LogradouroTipoIsValid;
use App\Rules\Bpa\NumeroIsRequired;
use App\Rules\Bpa\PacienteNomeIsRequired;
use App\Rules\Cns as CnsPacienteIsValid;
use App\Rules\Cns as CnsUsuarioIsValid;
use App\Rules\Sigtap\CidExists;
use App\Rules\Sigtap\CidIsValidForSexo;
use App\Rules\Sigtap\ClassificacaoIsValidForProcedimento;
use App\Rules\Sigtap\ClassificacaoIsValidForServico;
use App\Rules\Sigtap\CompetenciaIsValid;
use App\Rules\Sigtap\FinanciamentoIsValidForCompetencia;
use App\Rules\Sigtap\OcupacaoExists;
use App\Rules\Sigtap\ProcedimentoExists;
use App\Rules\Sigtap\ProcedimentoIsValidForCid;
use App\Rules\Sigtap\ProcedimentoIsValidForCompetencia;
use App\Rules\Sigtap\ProcedimentoIsValidForIdade;
use App\Rules\Sigtap\ProcedimentoIsValidForOcupacao;
use App\Rules\Sigtap\ProcedimentoIsValidForSexo;
use App\Rules\Sigtap\ProcedimentoRequireCid;
use App\Rules\Sigtap\QuantidadeIsValid;
use App\Rules\Sigtap\QuantidadeIsValidForProcedimento;
use App\Services\Service;
use Carbon\Carbon;
use Exception;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Str;

class ExportacaoService extends Service
{
    const BASE_PATH = 'faturamento' . DIRECTORY_SEPARATOR . 'bpa' . DIRECTORY_SEPARATOR;

    public static function create()
    {
        return [
            'form' => self::getForm(),
            'model' => self::getModel(),
        ];
    }

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

        self::validate($request);

        DB::transaction(function () use ($request) {
            $exportacao = Exportacao::create([
                'status_id' => ExportacaoStatus::AGUARDANDO_PROCESSAMENTO,
                'competencia_id' => $request->competencia_id,
            ]);

            $unidades = DB::table('cadastro_unidade')
                ->select(['cadastro_unidade.id'])
                ->whereExists(fn ($q) => $q
                    ->select(DB::raw(1))
                    ->from('bpa_procedimento')
                    ->join('sigtap.procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
                    ->whereNull('bpa_procedimento.exportacao_id')
                    ->whereNull('bpa_procedimento.deleted_at')
                    ->where('bpa_procedimento.competencia_id', $request->competencia_id)
                    ->whereIn('procedimento.competencia_id', self::getCompetencias($request->competencia_id)->pluck('id'))
                    ->whereColumn('bpa_procedimento.competencia_id', '>=', 'procedimento.competencia_id')
                    ->whereColumn('bpa_procedimento.unidade_id', 'cadastro_unidade.id')
                )
                ->when($request->cnes, fn ($q) => $q->where('cadastro_unidade.cnes', $request->cnes))
                ->when($request->unidade_id, fn ($q) => $q->where('cadastro_unidade.id', $request->unidade_id))
                ->get();

            $exportacao->unidades()->sync($unidades->pluck('id'));
            $exportacao->financiamentos()->sync($request->financiamentos);

            ExportacaoJob::dispatch(app('config')->get('database.default'), $exportacao->id);
        });
    }

    public static function update($request, $id)
    {
        return Exportacao::findOrFail($id)->update([
            'encaminhado' => $request->encaminhado
        ]);
    }

    public static function destroy($id)
    {
        $exportacao = Exportacao::where('id', $id)
            ->where('encaminhado', false)
            ->firstOrFail();

        DB::transaction(function() use ($exportacao) {
            Procedimento::where('exportacao_id', $exportacao->id)->get()->each(function ($procedimento) {
                $procedimento->inconsistencias()->sync([]);
                $procedimento->update(['exportacao_id' => null]);
            });

            $filePath = self::BASE_PATH . app('config')->get('database.default') . DIRECTORY_SEPARATOR  . $exportacao->arquivo;

            if (Storage::exists($filePath)) {
                Storage::delete($filePath);
            }

            $exportacao->delete();
        });

        return $exportacao;
    }

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

        switch (request()->listar) {
            case 'meses': {
                return [
                    'meses' => self::getMeses($params),
                ];
            }
            case 'cnes': {
                return [
                    'cnes' => self::getCnes($params),
                    'financiamentos' => self::getFinanciamentos($params),
                ];
            }
            case 'unidades': {
                return [
                    'unidades' => self::getUnidades($params),
                ];
            }
        }
    }

    public static function datatable()
    {
        return DB::table('bpa_exportacao')
            ->select([
                'bpa_exportacao.id',
                'bpa_exportacao.created_at AS data_hora_exportacao',
                'competencia.valor AS competencia_valor',
                DB::raw("
                    (
                        SELECT      GROUP_CONCAT(DISTINCT(cadastro_unidade.cnes) SEPARATOR ', ')
                        FROM        bpa_exportacao_unidade
                        INNER JOIN  cadastro_unidade
                        ON          cadastro_unidade.id = bpa_exportacao_unidade.unidade_id
                        WHERE       bpa_exportacao_unidade.exportacao_id = bpa_exportacao.id
                        ORDER BY    cadastro_unidade.cnes
                    )  AS unidade_cnes
                "),
                DB::raw("
                    (
                        SELECT      GROUP_CONCAT(financiamento.nome SEPARATOR ', ')
                        FROM        bpa_exportacao_financiamento
                        INNER JOIN  sigtap.financiamento
                        ON          financiamento.id = bpa_exportacao_financiamento.financiamento_id
                        WHERE       bpa_exportacao_financiamento.exportacao_id = bpa_exportacao.id
                    )  AS financiamento_nome
                "),
                'bpa_exportacao_status.id AS status_id',
                'bpa_exportacao_status.nome AS status_nome',
                'bpa_exportacao.quantidade_consistencia',
                'bpa_exportacao.quantidade_inconsistencia',
                DB::raw("bpa_exportacao.encaminhado"),
            ])
            ->join('sigtap.competencia', 'competencia.id', 'bpa_exportacao.competencia_id')
            ->join('bpa_exportacao_status', 'bpa_exportacao_status.id', 'bpa_exportacao.status_id')
            ->whereNull('bpa_exportacao.deleted_at');
    }

    public static function download($id)
    {
        $exportacao = Exportacao::findOrFail($id);

        return [
            'nome' => $exportacao->arquivo,
            'arquivo' => Storage::path(self::BASE_PATH . app('config')->get('database.default') . DIRECTORY_SEPARATOR  . $exportacao->arquivo),
        ];
    }

    public static function generate($cliente, $params)
    {
        $file = self::getArquivo($params);

        $path = self::BASE_PATH . $cliente . DIRECTORY_SEPARATOR;

        $saved = Storage::put($path . $file['nome'], $file['conteudo']);

        if ($saved) {
            chmod(Storage::path($path), 0775);
        } else {
            throw new Exception('Erro ao salvar o arquivo.');
        }

        return $file;
    }

    private static function getForm()
    {
        return [
            'anos' => self::getAnos(),
            'meses' => [],
            'cnes' => [],
            'unidades' => [],
            'financiamentos' => [],
        ];
    }

    private static function getModel()
    {
        return [
            'ano' => null,
            'competencia_id' => null,
            'cnes' => null,
            'unidade_id' => null,
            'financiamentos' => [],
        ];
    }

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

    private static function validate($request)
    {
        return $request->validate([
            'competencia_id' => [
                'required',
                'integer',
                new CompetenciaIsValid(),
            ],
            'cnes' => [
                'nullable',
                'string',
                'exists:cadastro_unidade,cnes',
            ],
            'unidade_id' => [
                'nullable',
                'integer',
                'exists:cadastro_unidade,id',
            ],
            'financiamentos' => [
                'required',
                'array',
                'distinct',
                new FinanciamentoIsValidForCompetencia($request->competencia_id),
            ],
        ]);
    }

    private static function getCompetencias($id = null)
    {
        $competencias = DB::table('sigtap.competencia')
            ->select([
                'id',
                'valor',
            ])
            ->orderByDesc('valor')
            ->limit(4);

        if (is_numeric($id)) {
            $competencias->where('id', '<=', $id);
        }

        return DB::query()
            ->fromSub($competencias, 'competencia')
            ->whereExists(function ($query) {
                $query->select(DB::raw(1))
                    ->from('bpa_procedimento')
                    ->join('sigtap.procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
                    ->whereNull('bpa_procedimento.exportacao_id')
                    ->whereNull('bpa_procedimento.deleted_at')
                    ->whereColumn('bpa_procedimento.competencia_id', '>=', 'procedimento.competencia_id')
                    ->whereColumn('bpa_procedimento.competencia_id', 'competencia.id');
            })
            ->orderByDesc('valor')
            ->get();
    }

    private static function getAnos()
    {
        $competencias = DB::table('sigtap.competencia')
            ->select([
                'id',
                'valor',
            ])
            ->orderByDesc('valor')
            ->limit(4);

        return DB::query()
            ->fromSub($competencias, 'competencia')
            ->whereExists(function ($query) {
                $query->select(DB::raw(1))
                    ->from('bpa_procedimento')
                    ->join('sigtap.procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
                    ->whereNull('bpa_procedimento.exportacao_id')
                    ->whereNull('bpa_procedimento.deleted_at')
                    ->whereIn('procedimento.competencia_id', self::getCompetencias()->pluck('id'))
                    ->whereColumn('bpa_procedimento.competencia_id', '>=', 'procedimento.competencia_id')
                    ->whereColumn('bpa_procedimento.competencia_id', 'competencia.id');
            })
            ->orderByDesc('valor')
            ->get()
            ->map(fn ($competencia) => [
                'value' => Str::substr($competencia->valor, 0, 4),
                'text' => Str::substr($competencia->valor, 0, 4),
            ])
            ->unique()
            ->values();
    }

    private static function getMeses($params)
    {
        $competencias = DB::table('sigtap.competencia')
            ->select([
                'id',
                'valor',
            ])
            ->whereRaw("SUBSTRING(valor, 1, 4) = " . $params->ano)
            ->orderByDesc('valor')
            ->limit(4);

        return DB::query()
            ->fromSub($competencias, 'competencia')
            ->whereExists(function ($query) {
                $query->select(DB::raw(1))
                    ->from('bpa_procedimento')
                    ->join('sigtap.procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
                    ->whereNull('bpa_procedimento.exportacao_id')
                    ->whereNull('bpa_procedimento.deleted_at')
                    ->whereIn('procedimento.competencia_id', self::getCompetencias()->pluck('id'))
                    ->whereColumn('bpa_procedimento.competencia_id', '>=', 'procedimento.competencia_id')
                    ->whereColumn('bpa_procedimento.competencia_id', 'competencia.id');
            })
            ->orderByDesc('valor')
            ->get()
            ->map(fn ($competencia) => [
                'id' => $competencia->id,
                'valor' => Str::substr($competencia->valor, 4, 2),
            ])
            ->values();
    }

    private static function getCnes($params)
    {
        return DB::table('cadastro_unidade')
            ->select([
                'cadastro_unidade.cnes AS text',
                'cadastro_unidade.cnes AS value',
            ])
            ->whereExists(fn ($q) => $q
                ->select(DB::raw(1))
                ->from('bpa_procedimento')
                ->join('sigtap.procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
                ->whereNull('bpa_procedimento.exportacao_id')
                ->whereNull('bpa_procedimento.deleted_at')
                ->where('bpa_procedimento.competencia_id', $params->competencia_id)
                ->whereIn('procedimento.competencia_id', self::getCompetencias($params->competencia_id)->pluck('id'))
                ->whereColumn('bpa_procedimento.competencia_id', '>=', 'procedimento.competencia_id')
                ->whereColumn('bpa_procedimento.unidade_id', 'cadastro_unidade.id')
            )
            ->groupBy('cadastro_unidade.cnes')
            ->orderBy('cadastro_unidade.cnes')
            ->get();
    }

    private static function getUnidades($params)
    {
        return DB::table('cadastro_unidade')
            ->select([
                'cadastro_unidade.id',
                'cadastro_unidade.nome_fantasia',
                'cadastro_unidade.cnes',
            ])
            ->whereExists(fn ($q) => $q
                ->select(DB::raw(1))
                ->from('bpa_procedimento')
                ->join('sigtap.procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
                ->whereNull('bpa_procedimento.exportacao_id')
                ->whereNull('bpa_procedimento.deleted_at')
                ->where('bpa_procedimento.competencia_id', $params->competencia_id)
                ->whereIn('procedimento.competencia_id', self::getCompetencias($params->competencia_id)->pluck('id'))
                ->whereColumn('bpa_procedimento.competencia_id', '>=', 'procedimento.competencia_id')
                ->whereColumn('bpa_procedimento.unidade_id', 'cadastro_unidade.id')
            )
            ->where('cadastro_unidade.cnes', $params->cnes)
            ->orderBy('cadastro_unidade.nome_fantasia')
            ->get();
    }

    private static function getFinanciamentos($params)
    {
        return DB::table('sigtap.financiamento')
            ->select([
                'id',
                'nome',
            ])
            ->where('competencia_id', $params->competencia_id)
            ->orderBy('nome')
            ->get();
    }

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

    private static function getArquivo($params)
    {
        $nome = Carbon::now()->format('dmYhis') . '.TXT';
        $conteudo = '';
        $cabecalho = self::getCabecalhoArquivo($params);
        $linhas = [];
        $consistencias = 0;
        $inconsistencias = 0;
        $controle = 0;

        self::storeLinhasProcedimentosConsolidados($params, $linhas, $consistencias, $inconsistencias);
        self::storeLinhasProcedimentosIndividualizados($params, $linhas, $consistencias, $inconsistencias);

        $cabecalho['cbc-lin'] = Str::padLeft(sizeof($linhas), 6, '0');
        $cabecalho['cbc-flh'] = Str::padLeft(ceil(sizeof($linhas) / 20), 6, '0');

        foreach ($linhas as $linha) {
            $controle += (int) $linha['prd-pa'] + (int) $linha['prd-qt'];
        }

        $cabecalho['cbc-smt-vrf'] = Str::padLeft(($controle % 1111) + 1111, 4, '0');

        foreach ($cabecalho as $value) {
            $conteudo .= $value;
        }

        foreach ($linhas as $linha) {
            foreach ($linha as $value) {
                $conteudo .= $value;
            }
        }

        return [
            'nome' => $nome,
            'conteudo' => $conteudo,
            'consistencias' => $consistencias,
            'inconsistencias' => $inconsistencias,
        ];
    }

    private static function getCabecalhoArquivo($params)
    {
        $competencia = DB::table('sigtap.competencia')
            ->select('valor')
            ->where('id', $params['competencia_id'])
            ->first();

        return [
            'cbc-hdr' => '01',
            'Cbc-hdr' => '#BPA#',
            'cbc-mvm' => $competencia->valor,
            'cbc-lin' => null,
            'cbc-flh' => null,
            'cbc-smt-vrf' => null,
            'cbc-rsp' => Str::padRight('CONECTASUS', 30, ' '),
            'cbc-sgl' => Str::padRight('CSUS', 6, ' '),
            'cbc-cgccpf' => Str::padLeft('', 14, '0'),
            'cbc-dst' => Str::padRight('', 40, ' '),
            'cbc-dst-in' => 'E',
            'cbc_versao' => Str::padRight('1.0', 10, ' '),
            'cbc-fim' => chr(13).chr(10),
        ];
    }

    private static function getFolhaAndSequencia(&$folha, &$sequencia, $registro)
    {

        $limite = $registro == Registro::BPA_INDIVIDUALIZADO ? 99 : 20;

        $sequencia++;

        if ($sequencia > $limite) {
            $folha++;
            $sequencia = 1;
        }
    }

    private static function storeLinhasProcedimentosConsolidados($params, &$linhas, &$consistencias, &$inconsistencias)
    {
        $folha = 1;
        $sequencia = 0;
        $competencias = self::getCompetencias($params['competencia_id']);

        self::getCompetencias($params['competencia_id'])
            ->map(function($competencia) use ($params, $competencias, &$folha, &$sequencia, &$linhas, &$consistencias, &$inconsistencias) {
                self::getProcedimentosConsolidados($params, $competencia)
                    ->get()
                    ->map(function($linha) use ($params, $competencias, &$folha, &$sequencia, &$linhas, &$consistencias, &$inconsistencias) {
                        $errors = collect();

                        if (!CnesIsValid::isValid($linha->unidade_cnes)) {
                            $errors->push(CnesIsValid::class);
                        }

                        if (!CompetenciaIsValid::isValid($linha->competencia_id, $params['competencia_id'])) {
                            $errors->push(CompetenciaIsValid::class);
                        }

                        if (!ProcedimentoIsValidForCompetencia::isValid($competencias, $linha->procedimento_id)) {
                            $errors->push(ProcedimentoIsValidForCompetencia::class);
                        }

                        if (!ProcedimentoExists::isValid($linha->procedimento_id)) {
                            $errors->push(ProcedimentoExists::class);
                        }

                        if (!ProcedimentoIsValidForOcupacao::isValid($linha->ocupacao_id, $linha->procedimento_id)) {
                            $errors->push(ProcedimentoIsValidForOcupacao::class);
                        }

                        if (!OcupacaoExists::isValid($linha->ocupacao_id)) {
                            $errors->push(OcupacaoExists::class);
                        }

                        if (!QuantidadeIsValid::isValid($linha->quantidade)) {
                            $errors->push(QuantidadeIsValid::class);
                        }

                        $procedimentos = DB::table('bpa_procedimento')
                            ->join('sigtap.registro', 'registro.id', 'bpa_procedimento.registro_id')
                            ->join('cadastro_unidade', 'cadastro_unidade.id', 'bpa_procedimento.unidade_id')
                            ->where('registro.codigo', Registro::BPA_CONSOLIDADO)
                            ->where('bpa_procedimento.competencia_id', $linha->competencia_id)
                            ->where('cadastro_unidade.cnes', $linha->unidade_cnes)
                            ->where('bpa_procedimento.procedimento_id', $linha->procedimento_id)
                            ->where('bpa_procedimento.ocupacao_id', $linha->ocupacao_id)
                            ->where('bpa_procedimento.origem', $linha->origem);

                        if ($errors->count() === 0) {
                            self::getFolhaAndSequencia($folha, $sequencia, Registro::BPA_CONSOLIDADO);

                            $linhas[] = [
                                'prd-ident' => '02',
                                'prd-cnes' => Str::padLeft(Str::substr($linha->unidade_cnes, 0, 7), 7, '0'),
                                'prd-cmp' => Str::padLeft(Str::substr($linha->competencia_valor, 0, 6), 6, '0'),
                                'Prd_cbo' => Str::padLeft(Str::substr($linha->ocupacao_codigo, 0, 6), 6, ' '),
                                'prd-flh' => Str::padLeft(Str::substr($folha, 0, 3), 3, '0'),
                                'prd-seq' => Str::padLeft(Str::substr($sequencia, 0, 2), 2, '0'),
                                'prd-pa' => Str::padLeft(Str::substr($linha->procedimento_codigo, 0, 10), 10, '0'),
                                'prd-ldade' => Str::padLeft(Str::substr($linha->idade, 0, 3), 3, '0'),
                                'prd-qt' => Str::padLeft(Str::substr($linha->quantidade, 0, 6), 6, '0'),
                                'prd-org' => 'BPA',
                                'prd-fim' => chr(13).chr(10),
                            ];

                            $consistencias++;
                        } else {
                            $procedimentos->select('bpa_procedimento.id')->get()->map(function($procedimento) use ($errors) {
                                self::storeInconsistencia($procedimento, $errors);
                            });

                            $inconsistencias++;
                        }

                        $procedimentos->update(['exportacao_id' => $params['exportacao_id']]);
                    });
            });
    }

    private static function storeLinhasProcedimentosIndividualizados($params, &$linhas, &$consistencias, &$inconsistencias)
    {
        $folha = 1;
        $sequencia = 0;
        $competencias = self::getCompetencias($params['competencia_id']);

        self::getCompetencias($params['competencia_id'])
            ->map(function($competencia) use ($params, $competencias, &$folha, &$sequencia, &$linhas, &$consistencias, &$inconsistencias) {
                self::getProcedimentosIndividualizados($params, $competencia)
                    ->get()
                    ->map(function($linha) use ($params, $competencias, &$folha, &$sequencia, &$linhas, &$consistencias, &$inconsistencias) {
                        $errors = collect();

                        if (!CnesIsValid::isValid($linha->unidade_cnes)) {
                            $errors->push(CnesIsValid::class);
                        }

                        if (!CompetenciaIsValid::isValid($linha->competencia_id, $params['competencia_id'])) {
                            $errors->push(CompetenciaIsValid::class);
                        }

                        if (!CnsUsuarioIsValid::isValid($linha->usuario_cns)) {
                            $errors->push('usuario_cns');
                        }

                        if (!OcupacaoExists::isValid($linha->ocupacao_id)) {
                            $errors->push(OcupacaoExists::class);
                        }

                        if (!PacienteNomeIsRequired::isValid($linha->paciente_nome)) {
                            $errors->push('paciente_nome_required');
                        }

                        if (!CnsPacienteIsValid::isValid($linha->paciente_cns)) {
                            $errors->push('paciente_cns');
                        }

                        if (!IdadeIsRequired::isValid($linha->paciente_idade)) {
                            $errors->push(IdadeIsRequired::class);
                        }

                        if (!EtniaIndigenaIsValid::isValid($linha->paciente_etnia_indigena_codigo_cadsus, $linha->paciente_raca_cor_id)) {
                            $errors->push(EtniaIndigenaIsValid::class);
                        }

                        if (!LogradouroTipoIsValid::isValid($linha->paciente_logradouro_tipo_codigo)) {
                            $errors->push(LogradouroTipoIsValid::class);
                        }

                        if (!CepIsValid::isValid($linha->paciente_logradouro_cep)) {
                            $errors->push(CepIsValid::class);
                        }

                        if (!LogradouroIsRequired::isValid($linha->paciente_logradouro_nome)) {
                            $errors->push(LogradouroIsRequired::class);
                        }

                        if (!NumeroIsRequired::isValid($linha->paciente_endereco_numero)) {
                            $errors->push(NumeroIsRequired::class);
                        }

                        if (!BairroIsRequired::isValid($linha->paciente_bairro_nome)) {
                            $errors->push(BairroIsRequired::class);
                        }

                        if (!ProcedimentoIsValidForCompetencia::isValid($competencias, $linha->procedimento_id)) {
                            $errors->push(ProcedimentoIsValidForCompetencia::class);
                        }

                        if (!ProcedimentoIsValidForSexo::isValid($linha->paciente_sexo, $linha->procedimento_id)) {
                            $errors->push(ProcedimentoIsValidForSexo::class);
                        }

                        if (!ProcedimentoExists::isValid($linha->procedimento_id)) {
                            $errors->push(ProcedimentoExists::class);
                        }

                        if (!ProcedimentoIsValidForOcupacao::isValid($linha->ocupacao_id, $linha->procedimento_id)) {
                            $errors->push(ProcedimentoIsValidForOcupacao::class);
                        }

                        if (!ProcedimentoIsValidForIdade::isValid($linha->paciente_idade, $linha->procedimento_id)) {
                            $errors->push(ProcedimentoIsValidForIdade::class);
                        }

                        if ($linha->cid_id && !ProcedimentoIsValidForCid::isValid($linha->cid_id, $linha->procedimento_id)) {
                            $errors->push(ProcedimentoIsValidForCid::class);
                        }

                        if(is_null($linha->cid_id)){

                            if (!ProcedimentoRequireCid::isValid($linha->procedimento_id)) {
                                $errors->push(ProcedimentoRequireCid::class);
                            }
                        }

                        if (!QuantidadeIsValid::isValid($linha->quantidade)) {
                            $errors->push(QuantidadeIsValid::class);
                        }

                        if (!QuantidadeIsValidForProcedimento::isValid($linha->procedimento_id, $linha->quantidade)) {
                            $errors->push(QuantidadeIsValidForProcedimento::class);
                        }

                        if (isset($linha->servico_id) && !is_int($linha->servico_id)) {
                            $errors->push('servico_id_integer');
                        }

                        if (!isset($linha->classificacao_id) && isset($linha->servico_id)) {
                            $errors->push('classificacao_id_required');
                        }

                        if (isset($linha->classificacao_id)) {
                            if (!is_int($linha->classificacao_id)) {
                                $errors->push('classificacao_id_integer');
                            } else {
                                if (!ClassificacaoIsValidForProcedimento::isValid($linha->procedimento_id, $linha->classificacao_id)) {
                                    $errors->push(ClassificacaoIsValidForProcedimento::class);
                                }

                                if (!ClassificacaoIsValidForServico::isValid($linha->servico_id, $linha->classificacao_id)) {
                                    $errors->push(ClassificacaoIsValidForServico::class);
                                }
                            }
                        }

                        if (isset($linha->cid_id)) {
                            if (!CidExists::isValid($linha->cid_id)) {
                                $errors->push(CidExists::class);
                            }

                            if (!CidIsValidForSexo::isValid($linha->paciente_sexo, $linha->cid_id)) {
                                $errors->push(CidIsValidForSexo::class);
                            }
                        }

                        if (!CaraterAtendimentoExists::isValid($linha->carater_atendimento_id)) {
                            $errors->push(CaraterAtendimentoExists::class);
                        }

                        $procedimento = DB::table('bpa_procedimento')->where('id', $linha->id);

                        if ($errors->count() === 0) {
                            self::getFolhaAndSequencia($folha, $sequencia, Registro::BPA_INDIVIDUALIZADO);

                            $linhas[] = [
                                'prd-ident' => '03',
                                'prd-cnes' => Str::padLeft(Str::substr($linha->unidade_cnes, 0, 7), 7, '0'),
                                'prd-cmp' => Str::padLeft(Str::substr($linha->competencia_valor, 0, 6), 6, ' '),
                                'Prd_cnsmed' => Str::padLeft(Str::substr($linha->usuario_cns, 0, 15), 15, '0'),
                                'Prd_cbo' => Str::padLeft(Str::substr($linha->ocupacao_codigo, 0, 6), 6, ' '),
                                'Prd_dtaten' => Str::padLeft(Str::substr($linha->data_atendimento, 0, 8), 8, ' '),
                                'prd-flh' => Str::padLeft(Str::substr($folha, 0, 3), 3, '0'),
                                'prd-seq' => Str::padLeft(Str::substr($sequencia, 0, 2), 2, '0'),
                                'prd-pa' => Str::padLeft(Str::substr($linha->procedimento_codigo, 0, 10), 10, ' '),
                                'Prd-cnspac' => $linha->paciente_cpf ? Str::padLeft('', 15, ' ') : Str::padLeft(Str::substr($linha->paciente_cns, 0, 15), 15, ' '),
                                'Prd-sexo' => Str::padLeft(Str::substr($linha->paciente_sexo, 0, 1), 1, ' '),
                                'Prd-ibge' => Str::padLeft(Str::substr($linha->paciente_municipio_ibge, 0, 6), 6, ' '),
                                'Prd-cid' => Str::padLeft(Str::substr($linha->cid_codigo, 0, 4), 4, ' '),
                                'prd-ldade' => Str::padLeft(Str::substr($linha->paciente_idade, 0, 3), 3, '0'),
                                'prd-qt' => Str::padLeft(Str::substr($linha->quantidade, 0, 6), 6, '0'),
                                'Prd-caten' => Str::padLeft(Str::substr($linha->carater_atendimento_codigo, 0, 2), 2, '0'),
                                'Prd-naut' => Str::padLeft(Str::substr('', 0, 13), 13, ' '),
                                'prd-org' => 'BPA',
                                'prd-nmpac' => Str::padRight(Str::ascii(Str::substr($linha->paciente_nome, 0, 30)), 30, ' '),
                                'prd-dtnasc' => Str::padLeft(Str::substr($linha->paciente_data_nascimento, 0, 8), 8, ' '),
                                'prd-raca' => Str::padLeft(Str::substr($linha->paciente_raca_cor_codigo, 0, 2), 2, ' '),
                                'prd-etnia' => Str::padLeft(Str::substr($linha->paciente_etnia_indigena_codigo_cadsus, 0, 4), 4, ' '),
                                'prd-nac' => Str::padLeft(Str::substr($linha->paciente_pais_codigo, 0, 3), 3, ' '),
                                'prd_srv' => Str::padLeft(Str::substr($linha->servico_codigo, 0, 3), 3, ' '),
                                'prd_clf' => Str::padLeft(Str::substr($linha->classificacao_codigo, 0, 3), 3, ' '),
                                'prd_equipe_Seq' => Str::padLeft(Str::substr('', 0, 8), 8, ' '),
                                'prd_equipe_Area' => Str::padLeft(Str::substr('', 0, 4), 4, ' '),
                                'prd_cnpj' => Str::padLeft(Str::substr('', 0, 14), 14, ' '),
                                'prd_cep_pcnte' => Str::padLeft($linha->paciente_logradouro_cep, 8, ' '),
                                'prd_lograd_pcnte' => Str::padLeft(Str::substr($linha->paciente_logradouro_tipo_codigo, 0, 3), 3, ' '),
                                'prd_end_pcnte' => Str::padRight(Str::ascii(Str::substr($linha->paciente_logradouro_nome, 0, 30)), 30, ' '),
                                'prd_compl_pcnte' => Str::padRight(Str::ascii(Str::substr($linha->paciente_endereco_complemento, 0, 10)), 10, ' '),
                                'prd_num_pcnte' => Str::padRight(Str::substr($linha->paciente_endereco_numero, 0, 5), 5, ' '),
                                'prd_bairro_pcnte' => Str::padRight(Str::ascii(Str::substr($linha->paciente_bairro_nome, 0, 30)), 30, ' '),
                                'prd_ddtel_pcnte' => Str::padRight(Str::substr($linha->paciente_telefone, 0, 11), 11, ' '),
                                'prd_email_pcnte' => Str::padRight(Str::substr($linha->paciente_email, 0, 40), 40, ' '),
                                'prd_ine' => Str::padLeft(Str::substr('', 0, 10), 10, ' '),
                                'prd_cpf_pcnte' => $linha->paciente_cpf ? Str::padLeft(Str::substr($linha->paciente_cpf, 0, 11), 11, ' ') : Str::padLeft('', 11, ' '),
                                'prd_situacao_rua' => $linha->paciente_situacao_rua,
                                'prd-fim' => chr(13).chr(10),
                            ];

                            $consistencias++;
                        } else {
                            self::storeInconsistencia($procedimento->select('id')->first(), $errors);
                            $inconsistencias++;
                        }

                        $procedimento->update(['exportacao_id' => $params['exportacao_id']]);
                    });
            });
    }

    private static function storeInconsistencia($procedimento, $errors)
    {
        foreach ($errors as $error) {
            if ($error === ProcedimentoIsValidForCompetencia::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::PROCEDIMENTO_NAO_CADASTRADO_NA_COMPETENCIA,
                ]);
            }

            if ($error === ProcedimentoIsValidForSexo::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::PROCEDIMENTO_NAO_PERMITIDO_PARA_O_SEXO,
                ]);
            }

            if ($error === ProcedimentoExists::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::PROCEDIMENTO_INVALIDO,
                ]);
            }

            if ($error === ProcedimentoIsValidForOcupacao::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::PROCEDIMENTO_NAO_PERMITIDO_PARA_O_CBO,
                ]);
            }

            if ($error === ProcedimentoIsValidForIdade::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::PROCEDIMENTO_NAO_PERMITIDO_PARA_A_IDADE,
                ]);
            }

            if ($error === ProcedimentoIsValidForCid::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::PROCEDIMENTO_INCOMPATIVEL_COM_CID,
                ]);
            }

            if ($error === OcupacaoExists::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::CBO_INEXISTENTE,
                ]);
            }

            if ($error === CaraterAtendimentoExists::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::CARATER_DE_ATENDIMENTO_INVALIDO,
                ]);
            }

            if ($error === IdadeIsRequired::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::IDADE_OBRIGATORIA,
                ]);
            }

            if ($error === EtniaIndigenaIsValid::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::ETNIA_INVALIDA,
                ]);
            }

            if ($error === QuantidadeIsValid::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::QUANTIDADE_ZERADA,
                ]);
            }

            if ($error === QuantidadeIsValidForProcedimento::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::EXCEDE_QUANTIDADE_MAXIMA_DO_PROCEDIMENTO,
                ]);
            }

            if ($error === CompetenciaIsValid::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::COMPETENCIA_INVALIDA,
                ]);
            }

            if ($error === 'usuario_cns') {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::CNS_DO_PROFISSIONAL_INVALIDO,
                ]);
            }

            if ($error === 'paciente_cns') {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::CNS_INVALIDO,
                ]);
            }

            if ($error === CidExists::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::CID_NAO_CADASTRADO,
                ]);
            }

            if ($error === CidIsValidForSexo::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::CID_NAO_PERMITIDO_PARA_O_SEXO,
                ]);
            }

            if ($error === ProcedimentoRequireCid::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::PROCEDIMENTO_EXIGE_CID,
                ]);
            }

            if ($error === DataAtendimentoIsValid::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::DATA_DE_ATENDIMENTO_INVALIDA,
                ]);
            }

            if ($error === LogradouroTipoIsValid::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::TIPO_LOGRADOURO_INVALIDO,
                ]);
            }

            if ($error === CepIsValid::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::CEP_INVALIDO,
                ]);
            }

            if ($error === LogradouroIsRequired::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::LOGRADOURO_OBRIGATORIO,
                ]);
            }

            if ($error === NumeroIsRequired::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::NUMERO_OBRIGATORIO,
                ]);
            }

            if ($error === BairroIsRequired::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::BAIRRO_OBRIGATORIO,
                ]);
            }

            if ($error === CnesIsValid::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::CNES_INVALIDO,
                ]);
            }

            if ($error === ClassificacaoIsValidForProcedimento::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::CLASSIFICACAO_INVALIDA_PARA_O_PROCEDIMENTO_INFORMADO,
                ]);
            }

            if ($error === ClassificacaoIsValidForServico::class) {
                DB::table('bpa_procedimento_inconsistencia')->updateOrInsert([
                    'procedimento_id' => $procedimento->id,
                    'inconsistencia_id' => Inconsistencia::CLASSIFICACAO_INVALIDA_PARA_O_SERVICO_INFORMADO,
                ]);
            }
        }
    }

    private static function getProcedimentosConsolidados($params, $competencia)
    {
        $financiamentos = DB::table('sigtap.financiamento')
            ->whereIn('competencia_id', self::getCompetencias($competencia->id)->pluck('id'))
            ->whereIn('codigo', DB::table('sigtap.financiamento')->whereIn('id', $params['financiamentos'])->pluck('codigo'))
            ->select(['id'])
            ->pluck('id');

        return DB::table('bpa_procedimento')
            ->select([
                'bpa_procedimento.origem',
                'cadastro_unidade.cnes AS unidade_cnes',
                'competencia.id AS competencia_id',
                'competencia.valor AS competencia_valor',
                'procedimento.id AS procedimento_id',
                'procedimento.codigo AS procedimento_codigo',
                'ocupacao.id AS ocupacao_id',
                'ocupacao.codigo AS ocupacao_codigo',
                'bpa_procedimento.idade',
                DB::raw('SUM(bpa_procedimento.quantidade) AS quantidade'),
            ])
            ->join('cadastro_unidade', 'cadastro_unidade.id', 'bpa_procedimento.unidade_id')
            ->join('sigtap.competencia', 'competencia.id', 'bpa_procedimento.competencia_id')
            ->join('sigtap.procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
            ->join('sigtap.registro', 'registro.id', 'bpa_procedimento.registro_id')
            ->leftJoin('sigtap.ocupacao', 'ocupacao.id', 'bpa_procedimento.ocupacao_id')
            ->where('registro.codigo', Registro::BPA_CONSOLIDADO)
            ->where('bpa_procedimento.competencia_id', $competencia->id)
            ->whereIn('cadastro_unidade.id', $params['unidades'])
            ->whereIn('procedimento.financiamento_id', $financiamentos)
            ->whereNull('bpa_procedimento.exportacao_id')
            ->whereNull('bpa_procedimento.deleted_at')
            ->whereColumn('bpa_procedimento.competencia_id', '>=', 'procedimento.competencia_id')
            ->groupBy([
                'bpa_procedimento.origem',
                'cadastro_unidade.cnes',
                'competencia.id',
                'procedimento.id',
                'ocupacao.id',
                'bpa_procedimento.idade',
            ]);
    }

    private static function getProcedimentosIndividualizados($params, $competencia)
    {
        $financiamentos = DB::table('sigtap.financiamento')
            ->whereIn('competencia_id', self::getCompetencias($competencia->id)->pluck('id'))
            ->whereIn('codigo', DB::table('sigtap.financiamento')->whereIn('id', $params['financiamentos'])->pluck('codigo'))
            ->select(['id'])
            ->pluck('id');

        return DB::table('bpa_procedimento')
            ->select([
                'bpa_procedimento.origem',
                'bpa_procedimento.id',
                'cadastro_unidade.cnes AS unidade_cnes',
                'competencia.id AS competencia_id',
                'competencia.valor AS competencia_valor',
                'cadastro_cidadao_usuario.id AS usuario_id',
                'cadastro_cidadao_usuario.nome AS usuario_nome',
                'cadastro_cidadao_usuario.cns AS usuario_cns',
                'ocupacao.id AS ocupacao_id',
                'ocupacao.codigo AS ocupacao_codigo',
                'cadastro_paciente.id AS paciente_id',
                'cadastro_cidadao_paciente.cpf as paciente_cpf',
                'cadastro_cidadao_paciente.nome AS paciente_nome',
                DB::raw("DATE_FORMAT(cadastro_cidadao_paciente.data_nascimento, '%Y%m%d') AS paciente_data_nascimento"),
                DB::raw('TIMESTAMPDIFF(YEAR, cadastro_cidadao_paciente.data_nascimento, NOW()) AS paciente_idade'),
                'cadastro_cidadao_paciente.cns AS paciente_cns',
                DB::raw("CASE WHEN cadastro_sexo_paciente.id = 1 THEN 'M' WHEN cadastro_sexo_paciente.id = 2 THEN 'F' END AS paciente_sexo"),
                'cadastro_raca_cor_paciente.id AS paciente_raca_cor_id',
                'cadastro_raca_cor_paciente.codigo AS paciente_raca_cor_codigo',
                'cadastro_etnia_indigena_paciente.codigo_cadsus AS paciente_etnia_indigena_codigo_cadsus',
                'cadastro_pais_paciente.codigo AS paciente_pais_codigo',
                'cadastro_logradouro_tipo_paciente.codigo AS paciente_logradouro_tipo_codigo',
                'cadastro_logradouro_paciente.nome AS paciente_logradouro_nome',
                DB::raw("COALESCE(cadastro_endereco_paciente.numero, 0) AS paciente_endereco_numero"),
                'cadastro_endereco_paciente.complemento AS paciente_endereco_complemento',
                'cadastro_bairro_paciente.nome AS paciente_bairro_nome',
                'cadastro_logradouro_paciente.cep AS paciente_logradouro_cep',
                'cadastro_municipio_paciente.nome AS paciente_municipio_nome',
                'cadastro_municipio_paciente.ibge AS paciente_municipio_ibge',
                DB::raw("
                    CASE
                        WHEN atencao_basica_cadastro_situacao_domicilio.id = ". CadastroDomicilioTipo::SITUACAO_DE_RUA . " then 'S'
                        ElSE 'N'
                    END as paciente_situacao_rua
                "),
                DB::raw("
                    (
                        SELECT      cadastro_cidadao_telefone.numero
                        FROM        cadastro_cidadao_telefone
                        WHERE       cadastro_cidadao_telefone.principal = TRUE
                        AND         cadastro_cidadao_telefone.cidadao_id = cadastro_cidadao_paciente.id
                        AND         cadastro_cidadao_telefone.deleted_at IS NULL
                        LIMIT       1
                    ) AS paciente_telefone
                "),
                'cadastro_paciente.email AS paciente_email',
                DB::raw("DATE_FORMAT(bpa_procedimento.data_atendimento, '%Y%m%d') AS data_atendimento"),
                'procedimento.id AS procedimento_id',
                'procedimento.codigo AS procedimento_codigo',
                'bpa_procedimento.quantidade',
                'servico.id AS servico_id',
                'servico.codigo AS servico_codigo',
                'classificacao.id AS classificacao_id',
                'classificacao.codigo AS classificacao_codigo',
                'cid.id AS cid_id',
                'cid.codigo AS cid_codigo',
                'bpa_carater_atendimento.id AS carater_atendimento_id',
                'bpa_carater_atendimento.codigo AS carater_atendimento_codigo',
            ])
            ->join('cadastro_unidade', 'cadastro_unidade.id', 'bpa_procedimento.unidade_id')
            ->join('sigtap.competencia', 'competencia.id', 'bpa_procedimento.competencia_id')
            ->join('cadastro_usuario', 'cadastro_usuario.id', 'bpa_procedimento.usuario_id')
            ->join('cadastro_cidadao AS cadastro_cidadao_usuario', 'cadastro_cidadao_usuario.id', 'cadastro_usuario.cidadao_id')
            ->join('cadastro_paciente', 'cadastro_paciente.id', 'bpa_procedimento.paciente_id')
            ->join('cadastro_cidadao AS cadastro_cidadao_paciente', 'cadastro_cidadao_paciente.id', 'cadastro_paciente.cidadao_id')
            ->join('sigtap.procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
            ->join('sigtap.registro', 'registro.id', 'bpa_procedimento.registro_id')
            ->leftJoin('cadastro_sexo AS cadastro_sexo_paciente', 'cadastro_sexo_paciente.id', 'cadastro_cidadao_paciente.sexo_id')
            ->leftJoin('cadastro_raca_cor AS cadastro_raca_cor_paciente', 'cadastro_raca_cor_paciente.id', 'cadastro_cidadao_paciente.raca_cor_id')
            ->leftJoin('intranet.cadastro_pais AS cadastro_pais_paciente', 'cadastro_pais_paciente.id', 'cadastro_cidadao_paciente.pais_nascimento_id')
            ->leftJoin('cadastro_domicilio AS cadastro_domicilio_paciente', 'cadastro_domicilio_paciente.id', 'cadastro_cidadao_paciente.domicilio_id')
            ->leftJoin('cadastro_domicilio_informacao_residencial','cadastro_domicilio_informacao_residencial.domicilio_id','cadastro_domicilio_paciente.id')
            ->leftJoin('atencao_basica_cadastro_situacao_domicilio', 'atencao_basica_cadastro_situacao_domicilio.id','cadastro_domicilio_informacao_residencial.situacao_domicilio_id' )
            ->leftJoin('cadastro_endereco AS cadastro_endereco_paciente', 'cadastro_endereco_paciente.id', 'cadastro_domicilio_paciente.endereco_id')
            ->leftJoin('cadastro_logradouro AS cadastro_logradouro_paciente', 'cadastro_logradouro_paciente.id', 'cadastro_endereco_paciente.logradouro_id')
            ->leftJoin('cadastro_logradouro_tipo AS cadastro_logradouro_tipo_paciente', 'cadastro_logradouro_tipo_paciente.id', 'cadastro_logradouro_paciente.tipo_id')
            ->leftJoin('intranet.cadastro_municipio AS cadastro_municipio_paciente', 'cadastro_municipio_paciente.id', 'cadastro_logradouro_paciente.municipio_id')
            ->leftJoin('cadastro_bairro AS cadastro_bairro_paciente', 'cadastro_bairro_paciente.id', 'cadastro_logradouro_paciente.bairro_id')
            ->leftJoin('cadastro_etnia_indigena AS cadastro_etnia_indigena_paciente', 'cadastro_etnia_indigena_paciente.id', 'cadastro_cidadao_paciente.etnia_indigena_id')
            ->leftJoin('sigtap.ocupacao', 'ocupacao.id', 'bpa_procedimento.ocupacao_id')
            ->leftJoin('sigtap.servico', 'servico.id', 'bpa_procedimento.servico_id')
            ->leftJoin('sigtap.classificacao', 'classificacao.id', 'bpa_procedimento.classificacao_id')
            ->leftJoin('sigtap.cid', 'cid.id', 'bpa_procedimento.cid_id')
            ->leftJoin('bpa_carater_atendimento', 'bpa_carater_atendimento.id', 'bpa_procedimento.carater_atendimento_id')
            ->where('registro.codigo', Registro::BPA_INDIVIDUALIZADO)
            ->where('bpa_procedimento.competencia_id', $competencia->id)
            ->whereIn('cadastro_unidade.id', $params['unidades'])
            ->whereIn('procedimento.financiamento_id', $financiamentos)
            ->whereNull('bpa_procedimento.exportacao_id')
            ->whereNull('bpa_procedimento.deleted_at')
            ->whereColumn('bpa_procedimento.competencia_id', '>=', 'procedimento.competencia_id');
    }
}