<?php

namespace App\Services\AtencaoBasica\Parametrizacao;

use App\Models\AtencaoBasica\Parametrizacao\Area;
use App\Models\AtencaoBasica\Parametrizacao\AreaTipo;
use App\Models\AtencaoBasica\Parametrizacao\Equipe;
use App\Models\AtencaoBasica\Parametrizacao\EquipeUsuario;
use App\Models\AtencaoBasica\Parametrizacao\FaturamentoAtendimentoDomiciliar;
use App\Models\AtencaoBasica\Parametrizacao\FaturamentoFuncionalidade;
use App\Models\AtencaoBasica\Parametrizacao\FaturamentoProcedimento;
use App\Models\AtencaoBasica\Parametrizacao\FaturamentoProcedimentoGrupo;
use App\Models\AtencaoBasica\Parametrizacao\Microarea;
use App\Models\AtencaoBasica\Parametrizacao\Outros;
use App\Models\AtencaoBasica\Parametrizacao\OutrosPermissao;
use App\Models\AtencaoBasica\Parametrizacao\OutrosPermissaoEsus;
use App\Models\AtencaoBasica\Parametrizacao\OutrosPermissaoOcupacao;
use App\Models\AtencaoBasica\Parametrizacao\OutrosSupervisor;
use App\Models\AtencaoBasica\Parametrizacao\RegistroTipo;
use App\Models\Cadastro\Estabelecimento\Unidade;
use App\Models\Cadastro\SujeitoAtencao\Lotacao;
use App\Models\Cadastro\SujeitoAtencao\Usuario;
use App\Models\Sigtap\Ocupacao;
use App\Models\Sigtap\Procedimento;
use App\Services\Service;
use Illuminate\Support\Facades\DB;

class ParametrizacaoService extends Service
{

    public static function index()
    {

        $model = self::getModelData();
        $form = self::getFormData();

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

    private static function getFormData()
    {

        return [
            'area' => [
                'tipos_area' => AreaTipo::all()->map(fn ($area) => [
                    'id' => $area->id,
                    'descricao' => $area->sigla ? $area->sigla .' - '. $area->descricao : '',
                ])->toArray(),
            ],
            'unidades' => self::obterUnidades()->toArray(),
            'faturamento' => [
                'atendimento_domiciliar' => [
                    'registro_tipo' => RegistroTipo::all()->toArray(),
                ],
            ],
            'outros' => [
                'permissao' => [
                    'ocupacoes' => Ocupacao::all(),
                ]
            ],
        ];
    }

    private static function obterAreas()
    {

        return Area::with('microareas')
            ->get()
            ->map(function($area) {

                $tipo = AreaTipo::find($area->tipo_id);


            if ($tipo) {
                $area->tipo_descricao = $tipo->sigla ? $tipo->sigla . ' - ' . $tipo->descricao : '-';
            } else {
                $area->tipo_descricao = '';
            }

                return $area;
            });
    }

    private static function obterUnidades()
    {

        return Unidade::orderBy('nome_fantasia')
            ->get()
            ->map(fn ($query) => [
                'id' => $query->id,
                'descricao' => $query->nome_fantasia,
                'infraestruturas' => $query->infraestruturas->sortBy('nome')->map(fn ($infraestrutura) => [
                    'id' => $infraestrutura->id,
                    'nome' => $infraestrutura->nome,
                    'principal' => $infraestrutura->principal,
                ])->values()
                ]);
    }

    private static function obterEquipes()
    {

        $equipes = DB::table("atencao_basica_parametrizacao_equipe as parametrizacao_equipe")
            ->select(
                'parametrizacao_equipe.id as equipe_id',
                'parametrizacao_equipe.microarea_id',
                'parametrizacao_area.id as area_id',
                'parametrizacao_area.descricao as area_descricao',
                'parametrizacao_area.numero_ine',
                'parametrizacao_microarea.descricao as microarea_descricao',
                'parametrizacao_area_tipo.sigla as area_tipo_sigla',
                'parametrizacao_area_tipo.descricao as area_tipo_descricao',
                'parametrizacao_unidade.id as unidade_id',
                'parametrizacao_unidade.nome_fantasia as unidade_descricao',
                'parametrizacao_infraestrutura.id as infraestrutura_id',
                DB::raw('COALESCE(parametrizacao_infraestrutura.nome, parametrizacao_infraestrutura_unidade.nome_fantasia) as infraestrutura_descricao'),
                'parametrizacao_usuario.id as usuario_id',
                'parametrizacao_cidadao.nome as usuario_nome',
                'parametrizacao_equipe_usuario.ativo as usuario_ativo',
                'sigtap_ocupacao.codigo as lotacao_codigo',
                'sigtap_ocupacao.nome as lotacao_nome',
            )
            ->join('atencao_basica_parametrizacao_area as parametrizacao_area', 'parametrizacao_area.id', 'parametrizacao_equipe.area_id')
            ->leftJoin('atencao_basica_parametrizacao_equipe_usuario as parametrizacao_equipe_usuario', 'parametrizacao_equipe_usuario.equipe_id', 'parametrizacao_equipe.id')
            ->leftJoin('cadastro_usuario as parametrizacao_usuario', 'parametrizacao_usuario.id', 'parametrizacao_equipe_usuario.usuario_id')
            ->leftJoin('cadastro_lotacao as parametrizacao_lotacao', 'parametrizacao_lotacao.usuario_id', 'parametrizacao_usuario.id')
            ->leftJoin('sigtap.ocupacao as sigtap_ocupacao', 'sigtap_ocupacao.id', 'parametrizacao_lotacao.ocupacao_id')
            ->leftJoin('cadastro_cidadao as parametrizacao_cidadao', 'parametrizacao_cidadao.id', 'parametrizacao_usuario.cidadao_id')
            ->leftJoin('cadastro_unidade as parametrizacao_unidade', 'parametrizacao_unidade.id', 'parametrizacao_equipe.unidade_id')
            ->leftJoin('atencao_basica_parametrizacao_microarea as parametrizacao_microarea', 'parametrizacao_microarea.id', 'parametrizacao_equipe.microarea_id')
            ->leftJoin('atencao_basica_parametrizacao_area_tipo as parametrizacao_area_tipo', 'parametrizacao_area_tipo.id', 'parametrizacao_area.tipo_id')
            ->leftJoin('cadastro_infraestrutura as parametrizacao_infraestrutura', 'parametrizacao_infraestrutura.id', 'parametrizacao_equipe.infraestrutura_id')
            ->leftJoin('cadastro_unidade as parametrizacao_infraestrutura_unidade', 'parametrizacao_infraestrutura_unidade.id', 'parametrizacao_infraestrutura.unidade_id')
            ->get()
            ->groupBy('equipe_id')
            ->map(function ($grupo) {
                $primeiro = collect($grupo)->first();
                return [
                    'id' => $primeiro->equipe_id,
                    'area_id' => $primeiro->area_id,
                    'area_descricao' => $primeiro->area_descricao,
                    'numero_ine' => $primeiro->numero_ine,
                    'microarea_id' => $primeiro->microarea_id,
                    'microarea_descricao' => $primeiro->microarea_descricao ?? 'Não informada',
                    'area_tipo' => $primeiro->area_tipo_sigla && $primeiro->area_tipo_descricao
                        ? $primeiro->area_tipo_sigla . ' - ' . $primeiro->area_tipo_descricao : '',
                    'unidade_id' => $primeiro->unidade_id,
                    'unidade_descricao' => $primeiro->unidade_descricao,
                    'infraestrutura_id' => $primeiro->infraestrutura_id ?? null,
                    'infraestrutura_descricao' => $primeiro->infraestrutura_descricao ?? null,
                    'usuarios' => $grupo
                        ->filter(fn($item) => !is_null($item->usuario_id))
                        ->groupBy('usuario_id')
                        ->map(function ($usuarios) {
                            $usuario = $usuarios->first();
                            $lotacoes = $usuarios->map(function ($item) {
                                return "{$item->lotacao_codigo} - {$item->lotacao_nome}";
                            })->unique()->implode('<br>');

                            return [
                                'id' => $usuario->usuario_id,
                                'nome' => $usuario->usuario_nome,
                                'ativo' => $usuario->usuario_ativo,
                                'lotacoes' => $lotacoes,
                            ];
                        })->values()
                ];
            })            
            ->values();

        return $equipes;

    }

    public static function getOcupacoes()
    {
        return Lotacao::where('usuario_id', request()->usuario_id)
            ->whereHas('infraestrutura', function ($query) {
                $query->where('infraestrutura_id', request()->infraestrutura_id);
            })
            ->get()
            ->map(fn ($lotacao) => $lotacao->ocupacao->codigo_nome)
            ->join('<br>');
    }

    private static function obterFaturamentoAtendimentoDomiciliar()
    {

        $faturamentoAtendimentoDomiciliar = FaturamentoAtendimentoDomiciliar::select('registro_tipo_id')
            ->first()
            ->toArray();

        return $faturamentoAtendimentoDomiciliar;
    }

    private static function obterOutrosSalarioMinimo()
    {

        $outrosSalarioMinimo = Outros::first()
            ->select('salario_minimo')
            ->get()
            ->toArray();

        return $outrosSalarioMinimo[0];
    }

    private static function obterSupervisores()
    {

        return OutrosSupervisor::with('usuarios')
            ->get()
            ->map(function ($supervisor) {

                $dadosUsuario = $supervisor->usuarios->map(fn ($usuario) => [
                    'id' => $usuario->id,
                    'nome' => $usuario->cidadao->nome
                ]);

                return [
                    'id' => $supervisor->id,
                    'usuario_id' => $dadosUsuario[0]['id'],
                    'usuario_nome' => $dadosUsuario[0]['nome'],
                ];
            });
    }

    private static function getModelData()
    {

        return [
            'area' => [
                'areas' => self::obterAreas()->toArray(),
            ],
            'equipe' => [
                'equipes' => self::obterEquipes()->toArray(),
            ],
            'faturamento' => [
                'atendimento_domiciliar' => self::obterFaturamentoAtendimentoDomiciliar(),
                'funcionalidades' => FaturamentoFuncionalidade::all()
                    ->map(fn ($faturamentoFuncionalidade) => [
                        'id' => $faturamentoFuncionalidade->id,
                        'descricao' => $faturamentoFuncionalidade->descricao,
                        'faturar' => $faturamentoFuncionalidade->faturar,
                    ]),
                'grupo_procedimentos' => FaturamentoProcedimentoGrupo::with('procedimentos')
                    ->get()
                    ->sortBy(['nome', 'competencia'])
                    ->map(function($grupo) {

                        $procedimentos = $grupo->procedimentos->map(function($procedimento) {

                            $procedimentoSigtap = Procedimento::where('codigo', $procedimento->codigo)
                                ->first('nome');

                            return [
                                'id' => $procedimento->id,
                                'codigo' => $procedimento->codigo,
                                'descricao' => $procedimentoSigtap->nome,
                                'faturar' => $procedimento->faturar
                            ];
                        });

                        return [
                            'id' => $grupo->id,
                            'descricao' => $grupo->descricao,
                            'procedimentos' => $procedimentos,
                        ];
                    }),
            ],
            'outros' => [
                'salario_minimo' => self::obterOutrosSalarioMinimo(),
                'supervisores' => self::obterSupervisores(),
                'permissao' => self::obterPermissoes(),
            ],
        ];
    }

    private static function obterNomeOcupacao($codigo)
    {

        $nome = Ocupacao::where('codigo', $codigo)
            ->get()
            ->map(fn ($ocupacao) => $ocupacao->nome);

        return $nome[0];
    }

    private static function obterDescricaoOcupacao($codigo)
    {

        $descricao = Ocupacao::where('codigo', $codigo)
            ->get()
            ->map(fn ($ocupacao) => $ocupacao->getCodigoNomeAttribute());

        return $descricao[0];
    }

    private static function obterPermissoes()
    {

        $permissoes = OutrosPermissao::with('ocupacoes')
            ->get()
            ->map(function ($permissao) {

                $ocupacoes = $permissao->ocupacoes
                    ->map(fn($permissaoOcupacao) => [
                            'codigo' => $permissaoOcupacao->ocupacao,
                            'descricao' => self::obterDescricaoOcupacao($permissaoOcupacao->ocupacao),
                            'id' => $permissaoOcupacao->id,
                            'nome' => self::obterNomeOcupacao($permissaoOcupacao->ocupacao),
                        ]);

                return [
                    'id' => $permissao->id,
                    'descricao' => $permissao->descricao,
                    'ocupacoes' => $ocupacoes
                ];
            });

        return $permissoes;
    }

    private static function incluirArea($dados)
    {

        unset($dados['microareas']);

        $area = new Area;

        $area->descricao = $dados['descricao'];
        $area->numero_ine = $dados['numero_ine'];
        $area->tipo_id = $dados['tipo_id'];

        $area->save();

        return $area->id;
    }

    private static function alterarArea($area)
    {

        unset($area['microareas']);

        $areaAntiga = Area::find($area['id']);

        if (
            $areaAntiga->descricao != $area['descricao'] ||
            $areaAntiga->numero_ine != $area['numero_ine'] ||
            $areaAntiga->tipo_id != $area['tipo_id']
        ) {

            Area::where('id', $area['id'])
                ->update($area);
        }
    }

    private static function excluirArea($ids = null)
    {

        if (!is_null($ids)) {

            self::excluirTodasMicroareasDaArea($ids);

            Area::whereIn('id', $ids)->delete();

        } else {

            self::excluirTodasMicroareas();

            Area::whereNotNull('id')
                ->delete();
        }
    }

    private static function incluirMicroarea($areaId, $descricao)
    {

        $microarea = new Microarea;

        $microarea->descricao = (int) $descricao;
        $microarea->area_id = $areaId;

        $microarea->save();

        return $microarea->id;
    }

    private static function excluirTodasMicroareas()
    {

        Microarea::whereNotNull('id')
            ->delete();
    }

    private static function excluirTodasMicroareasDaArea($areaIds)
    {

        if (is_array($areaIds)) {

            Microarea::whereIn('area_id', $areaIds)
                ->delete();
        } else {

            Microarea::where('area_id', $areaIds)
                ->delete();
        }
    }

    private static function excluirMicroareasEspecificas($areaId, $microareaIds)
    {

        Microarea::where('area_id', $areaId)
            ->where('id', $microareaIds)
            ->delete();
    }

    private static function obterMicroareasParaExcluir($areaId, $microareaIds)
    {

        return Microarea::where('area_id', $areaId)
            ->whereNotIn('id', $microareaIds)
            ->select('id')
            ->get()
            ->toArray();
    }

    private static function salvarMicroarea($areaId = null, $microareas = [])
    {

        if (!is_null($areaId) && sizeof($microareas) > 0) {

            $ids = [];

            foreach ($microareas as $microarea) {

                if (is_null($microarea['id'])) {

                    $id = self::incluirMicroarea($areaId, $microarea['descricao']);

                    array_push($ids, $id);
                } else {

                    array_push($ids, $microarea['id']);
                }
            }

            $idsParaExcluir = self::obterMicroareasParaExcluir($areaId, $ids);

            if (sizeof($idsParaExcluir) > 0) {

                self::excluirMicroareasEspecificas($areaId, $idsParaExcluir);
            }
        } elseif (!is_null($areaId)) {

            self::excluirTodasMicroareasDaArea($areaId);
        } else {

            self::excluirTodasMicroareas();
        }
    }

    private static function obterAreasParaExcluir($areaIds)
    {

        return Area::whereNotIn('id', $areaIds)
            ->select('id')
            ->get()
            ->map(fn ($area) => $area->id)
            ->toArray();
    }

    private static function salvarArea($areas)
    {

        if (sizeof($areas) > 0) {

            $ids = [];

            foreach ($areas as $area) {

                $id = null;

                if (!is_null($area['id'])) {

                    self::alterarArea($area);

                    $id = $area['id'];
                } else {

                    $id = self::incluirArea($area);
                }

                self::salvarMicroarea($id, $area['microareas']);

                array_push($ids, $id);
            }

            $idsParaExcluir = self::obterAreasParaExcluir($ids);

            if (sizeof($idsParaExcluir) > 0) {

                self::excluirArea($idsParaExcluir);
            }
        } else {

            self::excluirArea();
        }
    }

    private static function incluirEquipe($dados)
    {

        unset($dados['profissionais']);

        $equipe = new Equipe;

        $equipe->area_id = $dados['area_id'];
        $equipe->microarea_id = $dados['microarea_id'];
        $equipe->unidade_id = $dados['unidade_id'];
        $equipe->infraestrutura_id = $dados['infraestrutura_id'];

        $equipe->save();

        return $equipe->id;
    }

    private static function excluirEquipe($ids = null)
    {

        if (is_null($ids)) {

            self::excluirTodosUsuariosEquipes();

            Equipe::whereNotNull('id')
                ->delete();
        } else {

            self::excluirTodosUsuariosEquipesDaEquipe($ids);

            Equipe::whereIn('id', $ids)
                ->delete();
        }
    }

    private static function incluirEquipeUsuario($equipeId, $usuario)
    {

        if (!self::verificaSeProfissionalExisteEquipe($equipeId, $usuario['id'])) {

            $equipeUsuario = new EquipeUsuario;

            $equipeUsuario->equipe_id = $equipeId;
            $equipeUsuario->usuario_id = $usuario['id'];
            $equipeUsuario->ativo = $usuario['ativo'];

            $equipeUsuario->save();
        }
    }

    private static function excluirTodosUsuariosEquipes()
    {

        EquipeUsuario::whereNotNull('equipe_id')
            ->delete();
    }

    private static function excluirTodosUsuariosEquipesDaEquipe($equipeId)
    {

        if (is_array($equipeId)) {

            EquipeUsuario::whereIn('equipe_id', $equipeId)
                ->delete();
        } else {

            EquipeUsuario::where('equipe_id', $equipeId)
                ->delete();
        }
    }

    private static function excluirUsuariosEquipesEspecificos($equipeId, $usuarioIds)
    {

        EquipeUsuario::where('equipe_id', $equipeId)
            ->whereIn('usuario_id', $usuarioIds)
            ->delete();
    }

    private static function obterEquipesUsuariosParaExcluir($equipeId, $usuarioIds)
    {

        return EquipeUsuario::where('equipe_id', $equipeId)
            ->whereNotIn('usuario_id', $usuarioIds)
            ->select(['equipe_id', 'usuario_id'])
            ->get()
            ->toArray();
    }

    private static function verificaSeProfissionalExisteEquipe($equipeId, $usuarioId)
    {

        $profissional = EquipeUsuario::where('equipe_id', $equipeId)
            ->where('usuario_id', $usuarioId)
            ->select('usuario_id')
            ->get()
            ->toArray();

        if (is_array($profissional) && sizeof($profissional) > 0) {

            return $profissional[0]['usuario_id'] === $usuarioId;
        }

        return false;
    }

    private static function salvarEquipeUsuario($equipeId = null, $profissionais = [])
    {

        if (!is_null($equipeId) && sizeof($profissionais) > 0) {

            $ids = [];

            foreach ($profissionais as $profissional) {

                $estadoAtual = self::obterEstadoProfissional($profissional['id'], $equipeId);

                if ($estadoAtual !== null && isset($estadoAtual['ativo'])) {

                    self::atualizarEstadoProfissional($profissional['id'], $profissional['ativo'], $equipeId);
                } else {

                    self::incluirEquipeUsuario($equipeId, $profissional);
                }

                array_push($ids, $profissional['id']);
            }

            $idsParaExcluir = self::obterEquipesUsuariosParaExcluir($equipeId, $ids);

            if (sizeof($idsParaExcluir) > 0) {
                foreach ($idsParaExcluir as $key => $id) {
                    unset($idsParaExcluir[$key]['equipe_id']);
                };

                self::excluirUsuariosEquipesEspecificos($equipeId, $idsParaExcluir);
            }
        } else if (!is_null($equipeId)) {

            self::excluirTodosUsuariosEquipesDaEquipe($equipeId);
        } else {

            self::excluirTodosUsuariosEquipes();
        }
    }

    private static function obterEstadoProfissional($profissionalId, $equipeId)
    {

        $profissional = EquipeUsuario::where('usuario_id', $profissionalId)
            ->where('equipe_id', $equipeId)
            ->select('usuario_id', 'ativo', 'equipe_id')
            ->first();

        return $profissional ? $profissional->toArray() : null;
    }

    private static function atualizarEstadoProfissional($profissionalId, $novoEstado, $equipeId)
    {

        $alteraAtivo = EquipeUsuario::where('usuario_id', $profissionalId)
            ->where('equipe_id', $equipeId)
            ->update(['ativo' => $novoEstado]);

        return $alteraAtivo;
    }

    private static function obterEquipesParaExcluir($equipeIds)
    {

        return Equipe::whereNotIn('id', $equipeIds)
            ->select(['id'])
            ->get()
            ->map(fn ($equipe) => $equipe->id)
            ->toArray();
    }

    private static function salvarEquipe($equipes)
    {

        if (sizeof($equipes) > 0) {

            $ids = [];

            foreach ($equipes as $equipe) {

                if (is_null($equipe['id'])) {

                    $id = self::incluirEquipe($equipe);
                } else {

                    $id = $equipe['id'];
                }

                self::salvarEquipeUsuario($id, $equipe['profissionais']);

                array_push($ids, $id);
            }

            $idsParaExcluir = self::obterEquipesParaExcluir($ids);

            if (sizeof($idsParaExcluir) > 0) {

                self::excluirEquipe($idsParaExcluir);
            }

        } else {

            self::excluirEquipe();
        }
    }

    private static function obterOcupacoesPermitidasFuncionalidade($permissaoFuncionalidadeId)
    {

        return OutrosPermissaoEsus::where('permissao_id', $permissaoFuncionalidadeId)
            ->select('codigo')
            ->get()
            ->map(fn ($permissao) => $permissao->codigo);
    }

    public static function autocomplete()
    {
        $ocupacoesPermitidasFuncionalidade = self::obterOcupacoesPermitidasFuncionalidade(request()->funcionalidade_id);

        $ocupacao = DB::table("sigtap.ocupacao")
            ->select(
                "sigtap.ocupacao.codigo",
                "sigtap.ocupacao.nome",
                DB::raw("CONCAT(sigtap.ocupacao.codigo, ' - ', sigtap.ocupacao.nome) AS descricao"),
            )
            ->whereIn("codigo", $ocupacoesPermitidasFuncionalidade);

        return $ocupacao;
    }

    private static function salvarFaturamentoAtendimentoDomiciliar($dadosAtendimentoDomiciliar)
    {

        FaturamentoAtendimentoDomiciliar::where('id', 1)
            ->update($dadosAtendimentoDomiciliar);
    }

    private static function salvarFaturamentoFuncionalidades($dadosFuncionalidades)
    {

        foreach ($dadosFuncionalidades as $funcionalidade) {

            FaturamentoFuncionalidade::where('id', $funcionalidade['id'])
                ->update($funcionalidade);
        }
    }

    private static function salvarFaturamentoProcedimentos($dadosProcedimentos)
    {

        foreach ($dadosProcedimentos as $procedimento) {

            FaturamentoProcedimento::where('id', $procedimento['id'])
                ->update($procedimento);
        }
    }

    private static function salvarFaturamento($dadosFaturamento)
    {

        if (sizeof($dadosFaturamento) > 0) {

            self::salvarFaturamentoAtendimentoDomiciliar($dadosFaturamento['atendimento_domiciliar']);
            self::salvarFaturamentoFuncionalidades($dadosFaturamento['funcionalidades']);
            self::salvarFaturamentoProcedimentos($dadosFaturamento['procedimentos']);
        }
    }

    private static function salvarOutrosSalarioMinimo($dadosSalarioMinimo)
    {

        Outros::where('id', 1)
            ->update($dadosSalarioMinimo);
    }

    private static function obterSupervisoresParaExcluir($ids)
    {

        return OutrosSupervisor::whereNotIn('id', $ids)
            ->select(['id'])
            ->get()
            ->toArray();
    }

    private static function incluirSupervisor($dadosSupervisor)
    {

        $supervisor = new OutrosSupervisor;

        $supervisor->usuario_id = $dadosSupervisor['usuario_id'];

        $supervisor->save();

        return $supervisor->id;
    }

    private static function excluirSupervisores($ids)
    {

        if (sizeof($ids) > 0) {

            OutrosSupervisor::whereIn('id', $ids)
                ->delete();
        }
    }

    private static function salvarOutrosSupervisores($dadosSupervisores)
    {

        $ids = [];

        foreach ($dadosSupervisores as $supervisor) {

            if (is_null($supervisor['id'])) {

                $id = self::incluirSupervisor($supervisor);
            } else {

                $id = $supervisor['id'];
            }

            array_push($ids, $id);
        }

        $idsParaExcluir = self::obterSupervisoresParaExcluir($ids);

        self::excluirSupervisores($idsParaExcluir);
    }

    private static function incluirPermissaoOcupacao($permissaoId, $codigo)
    {

        $ocupacao = new OutrosPermissaoOcupacao;

        $ocupacao->permissao_id = $permissaoId;
        $ocupacao->ocupacao = $codigo;

        $ocupacao->save();

        return $ocupacao->id;
    }

    private static function excluirPermissaoOcupacao($permissaoId, $ocupacaoIds)
    {

        OutrosPermissaoOcupacao::where('permissao_id', $permissaoId)
            ->whereIn('id', $ocupacaoIds)
            ->delete();
    }

    private static function obterIdentificacaoPermissaoOcupacao($permissaoId, $ocupacao)
    {

        $identificacao = OutrosPermissaoOcupacao::where('permissao_id', $permissaoId)
            ->where('ocupacao', $ocupacao)
            ->select('id')
            ->first();

        return $identificacao->id ?? null;
    }

    private static function obterOcupacaoPermissaoParaExcluir($ids)
    {

        return OutrosPermissaoOcupacao::whereNotIn('id', $ids)
            ->select(['id'])
            ->get()
            ->toArray();
    }

    private static function salvarOutrosPermissao($dadosPermissao)
    {

        foreach ($dadosPermissao as $permissao) {

            $ids = [];

            foreach ($permissao['ocupacoes'] as $ocupacao) {

                $permissaoOcupacaoId = self::obterIdentificacaoPermissaoOcupacao($permissao['id'], $ocupacao['ocupacao']);

                if (is_null($permissaoOcupacaoId)) {

                    $id = self::incluirPermissaoOcupacao($permissao['id'], $ocupacao['ocupacao']);
                } else {

                    $id = $permissaoOcupacaoId;
                }

                array_push($ids, $id);
            }

            $idsParaExcluir = self::obterOcupacaoPermissaoParaExcluir($ids);

            self::excluirPermissaoOcupacao($permissao['id'], $idsParaExcluir);
        }
    }

    private static function salvarOutros($dadosOutros)
    {

        if (sizeof($dadosOutros) > 0) {

            self::salvarOutrosSalarioMinimo($dadosOutros['salario_minimo']);
            self::salvarOutrosSupervisores($dadosOutros['supervisores']);
            self::salvarOutrosPermissao($dadosOutros['permissao']);
        }
    }

    public static function store($request)
    {
        self::salvarArea($request->areas);
        self::salvarEquipe($request->equipes);
        self::salvarFaturamento($request->faturamento);
        self::salvarOutros($request->outros);
    }
}