<?php

namespace App\Services\AtencaoBasica\AtividadeColetiva;

use App\Enums\AtencaoBasica\AtendimentoIndividual\LocalAtendimento;
use App\Enums\AtencaoBasica\Parametrizacao\Permissao;
use App\Models\AtencaoBasica\AtividadeColetiva\AtividadeColetiva;
use App\Models\AtencaoBasica\AtividadeColetiva\AtividadeTipo;
use App\Models\AtencaoBasica\AtividadeColetiva\Participante;
use App\Models\AtencaoBasica\AtividadeColetiva\Procedimento;
use App\Models\AtencaoBasica\AtividadeColetiva\ProcedimentoColetivo;
use App\Models\AtencaoBasica\AtividadeColetiva\Profissional;
use App\Models\AtencaoBasica\AtividadeColetiva\Pse;
use App\Models\AtencaoBasica\AtividadeColetiva\PublicoAlvo;
use App\Models\AtencaoBasica\AtividadeColetiva\ReuniaoTema;
use App\Models\AtencaoBasica\AtividadeColetiva\SaudePratica;
use App\Models\AtencaoBasica\AtividadeColetiva\SaudeTema;
use App\Models\AtencaoBasica\AtividadeColetiva\Turno;
use App\Models\AtencaoBasica\Parametrizacao\Equipe;
use App\Models\AtencaoBasica\Parametrizacao\OutrosPermissaoOcupacao;
use App\Models\AtencaoBasica\Parametrizacao\OutrosPermissaoEsus;
use App\Enums\AtencaoBasica\AtividadeColetiva\OutrasPermissoesEsus as OutrasPermissoesEsusEnum;
use App\Models\Cadastro\Estabelecimento\Infraestrutura;
use App\Models\Cadastro\Estabelecimento\Unidade;
use App\Models\Cadastro\SujeitoAtencao\Usuario;
use App\Models\Cns\TermoInvalido;
use App\Models\Sigtap\Ocupacao;
use App\Services\AtencaoBasica\Procedimento\ProcedimentoService;
use App\Services\Service;
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\Rule;

class AtividadeColetivaService extends Service
{

    public static function datatable()
    {
        $atividades = DB::table('atencao_basica_atividade_coletiva AS atividade_coletiva')
            ->select([
                'atividade_coletiva.id',
                'atividade_coletiva.data_cadastro',
                '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'),
                'cidadao_exportacao.nome as profissional_exportacao',
                DB::raw("DATE_FORMAT(exportacao.created_at, '%d/%m/%Y') AS data_exportacao"),
                DB::raw("DATE_FORMAT(exportacao.created_at, '%H:%i') AS horario_exportacao")
            ])
            ->leftJoin('cadastro_usuario', 'cadastro_usuario.id', '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', 'atividade_coletiva.atividade_tipo_id')
            ->leftJoin('atencao_basica_atividade_coletiva_saude_tema AS tema', 'tema.atividade_coletiva_id', 'atividade_coletiva.id')
            ->leftJoin('atencao_basica_cadastro_saude_tema AS saude_temas', 'saude_temas.id', 'tema.saude_tema_id')
            ->leftJoin('cadastro_usuario as usuario_exportacao', 'usuario_exportacao.id', 'atividade_coletiva.usuario_exportacao_id')
            ->leftJoin('cadastro_cidadao as cidadao_exportacao', 'cidadao_exportacao.id', 'usuario_exportacao.cidadao_id')
            ->leftJoin('atencao_basica_exportacao as exportacao', 'exportacao.id', 'atividade_coletiva.exportacao_id')
            ->groupBy('atividade_coletiva.id');

        return datatables()
            ->of($atividades)
            ->filterColumn('atividade_coletiva.data_cadastro', function ($query, $keyword) {

                $query->whereRaw("DATE_FORMAT(atividade_coletiva.data_cadastro, '%d/%m/%Y') like ?", ["%{$keyword}%"])
                    ->orWhereRaw(
                        "CONCAT(
                            SUBSTR(atividade_coletiva.data_cadastro,9,2),
                            SUBSTR(atividade_coletiva.data_cadastro,6,2),
                            SUBSTR(atividade_coletiva.data_cadastro,1,4)
                        ) like ?",
                        ["%{$keyword}%"]
                    );
            })
            ->filterColumn('profissional_responsavel', function ($query, $keyword) {

                $query->whereRaw("CASE WHEN cadastro_cidadao.nome_social IS NOT NULL THEN cadastro_cidadao.nome_social ELSE cadastro_cidadao.nome END like ?", ["%{$keyword}%"]);
            })
            ->filterColumn('local_atividade', function ($query, $keyword) {

                $query->whereRaw("CASE WHEN inep IS NOT NULL THEN inep WHEN local_atividade IS NOT NULL THEN local_atividade ELSE cnes END like ?", ["%{$keyword}%"]);
            })
            ->filterColumn('saude_temas', function ($query, $keyword) {

                $query->havingRaw("GROUP_CONCAT(saude_temas.descricao SEPARATOR ', ') like ?", ["%{$keyword}%"]);
            })
            ->skipTotalRecords()
            ->toJson();
    }

    public static function index()
    {

        return [
            'model' => self::getModelData(),
            'form' => [],
        ];
    }

    public static function getEquipes(){

        return DB::table('atencao_basica_parametrizacao_equipe_usuario')
            ->select([
                'atencao_basica_parametrizacao_equipe.id AS id',
                DB::raw("
                    CONCAT(
                        CASE
                            WHEN atencao_basica_parametrizacao_area.numero_ine IS NOT NULL THEN CONCAT('INE: ', atencao_basica_parametrizacao_area.numero_ine)
                            ELSE ''
                        END,
                        CASE
                            WHEN atencao_basica_parametrizacao_area.descricao IS NOT NULL AND atencao_basica_parametrizacao_area.numero_ine IS NOT NULL THEN ' - Área: '
                            WHEN atencao_basica_parametrizacao_area.descricao IS NOT NULL THEN 'Área: '
                            ELSE ''
                        END,
                        COALESCE(atencao_basica_parametrizacao_area.descricao, ''),
                        CASE
                            WHEN atencao_basica_parametrizacao_microarea.descricao IS NOT NULL AND (atencao_basica_parametrizacao_area.numero_ine IS NOT NULL OR atencao_basica_parametrizacao_area.descricao IS NOT NULL) THEN ' - Microárea: '
                            WHEN atencao_basica_parametrizacao_microarea.descricao IS NOT NULL THEN 'Microárea: '
                            ELSE ''
                        END,
                        COALESCE(atencao_basica_parametrizacao_microarea.descricao, '')
                    ) AS descricao
                ")
            ])
            ->join('atencao_basica_parametrizacao_equipe', 'atencao_basica_parametrizacao_equipe.id', 'atencao_basica_parametrizacao_equipe_usuario.equipe_id')
            ->join('cadastro_unidade', 'cadastro_unidade.id', 'atencao_basica_parametrizacao_equipe.unidade_id')
            ->leftJoin('atencao_basica_parametrizacao_area', 'atencao_basica_parametrizacao_area.id', 'atencao_basica_parametrizacao_equipe.area_id')
            ->leftJoin('atencao_basica_parametrizacao_microarea', 'atencao_basica_parametrizacao_microarea.id', 'atencao_basica_parametrizacao_equipe.microarea_id')
            ->where('atencao_basica_parametrizacao_equipe_usuario.ativo', true)
            ->when(request()->usuario_id, fn ($q, $id) => $q->where('atencao_basica_parametrizacao_equipe_usuario.usuario_id', $id))
            ->when(request()->infraestrutura_id, fn ($q, $id) => $q->where('atencao_basica_parametrizacao_equipe.infraestrutura_id', $id))
            ->get();
    }

    public static function getUnidades(){

        return DB::table('atencao_basica_parametrizacao_equipe_usuario')
            ->select([
                'cadastro_unidade.id AS id',
                'cadastro_unidade.nome_fantasia AS nome_fantasia',
            ])
            ->join('atencao_basica_parametrizacao_equipe', 'atencao_basica_parametrizacao_equipe.id', 'atencao_basica_parametrizacao_equipe_usuario.equipe_id')
            ->join('cadastro_unidade', 'cadastro_unidade.id', 'atencao_basica_parametrizacao_equipe.unidade_id')
            ->where('atencao_basica_parametrizacao_equipe_usuario.ativo', true)
            ->when(request()->usuario_id, fn ($q, $id) => $q->where('atencao_basica_parametrizacao_equipe_usuario.usuario_id', $id))
            ->distinct()
            ->get();
    }

    public static function getInfraestruturas(){

        return DB::table('atencao_basica_parametrizacao_equipe_usuario')
        ->select([
            'cadastro_infraestrutura.id AS id',
            DB::raw('COALESCE(cadastro_infraestrutura.nome, cadastro_unidade.nome_fantasia) AS nome'),
        ])
        ->join('atencao_basica_parametrizacao_equipe', 'atencao_basica_parametrizacao_equipe.id', 'atencao_basica_parametrizacao_equipe_usuario.equipe_id')
        ->join('cadastro_infraestrutura', 'cadastro_infraestrutura.id', 'atencao_basica_parametrizacao_equipe.infraestrutura_id')
        ->join('cadastro_unidade', 'cadastro_unidade.id', 'atencao_basica_parametrizacao_equipe.unidade_id')
        ->where('atencao_basica_parametrizacao_equipe_usuario.ativo', true)
        ->when(request()->usuario_id, fn ($q, $id) => $q->where('atencao_basica_parametrizacao_equipe_usuario.usuario_id', $id))
        ->when(request()->unidade_id, fn ($q, $id) => $q->where('atencao_basica_parametrizacao_equipe.unidade_id', $id))
        ->distinct()
        ->orderBy('nome')
        ->get();
    }

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

        return $usuario->lotacoes
            ->filter(function ($lotacao) use ($codigos) {
                    return  $codigos->contains($lotacao->ocupacao->codigo);
            })
            ->pluck('ocupacao');
    }

    private static function getFormData($cadastro = null)
    {

        return [
            'data_atual' => Carbon::now()->format('d/m/Y'),
            'turnos' => Turno::orderBy('id')->get(),
            'pse_id' => Pse::orderBy('id')->get(),
            'atividade_tipo' => AtividadeTipo::orderBy('id')->get(),
            'reuniao_temas' => ReuniaoTema::orderBy('id')->get(),
            'publico_alvo' => PublicoAlvo::orderBy('id')->get(),
            'saude_temas' => SaudeTema::orderBy('descricao')->get(),
            'saude_pratica' => SaudePratica::orderBy('id')->get(),
            'procedimentos_coletivos' => ProcedimentoColetivo::orderBy('id')->get(),
            'termos_invalidos' => TermoInvalido::all()->map(fn ($termo) => $termo->descricao),
        ];
    }

    private static function getModelData($cadastro = null)
    {

        return [
            'id' => $cadastro->id ?? null,
            'cadastro' => [
                'data_cadastro' => $cadastro->data_cadastro ?? null,
                'pse_id' => $cadastro->pse_id ?? null,
                'inep' =>  isset($cadastro->inep) ? strval($cadastro->inep) : null,
                'local_atividade' => $cadastro->local_atividade ?? null,
                'cnes' => $cadastro->cnes ?? null,
                'turno_id' => $cadastro->turno_id ?? null,
            ],
            'profissional' => [
                'usuario' => [
                    'id' => $cadastro->usuario->id ?? null,
                    'cidadao_nome' => $cadastro->usuario->cidadao->nome ?? null,
                ],
                'unidade_id' => $cadastro->equipe->unidade_id ?? null,
                'infraestrutura_id' => $cadastro->equipe->infraestrutura_id ?? null,
                'equipe_id' => $cadastro->equipe_id ?? null,
                'ocupacao_id' => $cadastro->usuario_ocupacao_id ?? null,
            ],
            'profissionais' => isset($cadastro->id) ?
                Profissional::where('atividade_coletiva_id', $cadastro->id)
                ->get()
                ->map(fn ($tipo) => [
                    'profissional_id' => $tipo->usuario_id,
                    'nome' => $tipo->usuario->cidadao->nome,
                    'ocupacao_id' => $tipo->usuario_ocupacao_id ?? null,
                    'ocupacaoNome' => ($tipo->ocupacao->codigo) . ' - ' . ($tipo->ocupacao->nome),
                ]) : [],
            'reuniao_temas' => isset($cadastro->reuniaoTemas) ? $cadastro->reuniaoTemas->pluck('id') : [],
            'publico_alvo' => isset($cadastro->publicoAlvo) ? $cadastro->publicoAlvo->pluck('id') : [],
            'saude_temas' => isset($cadastro->saudeTemas) ? $cadastro->saudeTemas->pluck('id') : [],
            'saude_pratica' => isset($cadastro->saudePratica) ? $cadastro->saudePratica->pluck('id') : [],
            'procedimento_coletivo_id' => $cadastro->procedimento_coletivo_id ?? null,
            'atividade' => [
                'atividade_tipo_id' => $cadastro->atividade_tipo_id ?? null,
                'total_participantes' => $cadastro->total_participantes ?? null,
                'avaliacoes_alteradas' => $cadastro->avaliacoes_alteradas ?? null,
            ],
            'participante' => $cadastro->participante ?? [],
            'participantes' => isset($cadastro->id) ?
            Participante::where('atividade_coletiva_id', $cadastro->id)
                ->get()
                ->map(fn ($tipo) => [
                    'id' => $tipo->paciente_id,
                    'nome' => $tipo->paciente->cidadao->nome,
                    'nome_social' => $tipo->paciente->cidadao->nome_social,
                    'cns' => $tipo->paciente->cidadao->cns,
                    'avaliacao_alterada' => $tipo->avaliacao_alterada ? 'Sim' : 'Não',
                    'peso' => $tipo->peso,
                    'altura' => $tipo->altura,
                    'parou_fumar' => $tipo->parou_de_fumar ? 'Sim' : 'Não',
                    'abandonou_grupo' => $tipo->abandonou_grupo ? 'Sim' : 'Não'
                ]) : [],
            'procedimento' => $cadastro->procedimentoPadrao ?? [],
            'procedimentos' => isset($cadastro->id) ?
                Procedimento::where('atividade_coletiva_id', $cadastro->id)
                    ->where('procedimento_padrao', '=', true)
                    ->get()
                    ->map(fn ($tipo) => [
                        'id' => $tipo->id,
                        'procedimento_id' => $tipo->procedimento->id,
                        'codigo' => $tipo->procedimento->codigo,
                        'nome' => $tipo->procedimento->nome,
                        'padrao' => $tipo->procedimento_padrao
                    ])
                : [],
            'procedimento_individual' => $cadastro->procedimentoIndividual ?? [],
            'procedimentos_individuais' => isset($cadastro->id) ?
                Procedimento::where('atividade_coletiva_id', $cadastro->id)
                    ->where('paciente_id', '!=', null)
                    ->get()
                    ->map(fn ($tipo) => [
                        'id' => $tipo->id,
                        'codigo' => $tipo->procedimento->codigo,
                        'nome' => $tipo->procedimento->nome,
                        'paciente_id' => $tipo->paciente_id,
                        'padrao' => $tipo->procedimento_padrao
                    ])
                : [],
        ];
    }

    public static function show($id)
    {

        return AtividadeColetiva::find($id);
    }

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

    public static function edit($id)
    {

        $cadastro = self::show($id);

        return [
            'form' => self::getFormData($cadastro),
            'model' => self::getModelData($cadastro),
        ];
    }

    public static function store()
    {

        self::validate();

        $atividadeColetiva = AtividadeColetiva::where('id', request()->id)
            ->first() ?? new AtividadeColetiva();

        $atividadeColetiva->id = request()->id;

        $cadastro = request()->cadastro;
        $atividadeColetiva->pse_id = $cadastro['pse_id'];
        $atividadeColetiva->inep = $cadastro['inep'];
        $atividadeColetiva->local_atividade = $cadastro['local_atividade'];
        $atividadeColetiva->cnes = $cadastro['cnes'];
        $atividadeColetiva->turno_id = $cadastro['turno_id'];
        $atividadeColetiva->data_cadastro = $cadastro['data_cadastro'];

        $atividade = request()->atividade;
        $atividadeColetiva->atividade_tipo_id = $atividade['atividade_tipo_id'];
        $atividadeColetiva->total_participantes = $atividade['total_participantes'];
        $atividadeColetiva->avaliacoes_alteradas = $atividade['avaliacoes_alteradas'];

        $profissional = request()->profissional;
        $atividadeColetiva->usuario_id = $profissional['usuario']['id'];
        $atividadeColetiva->equipe_id = $profissional['equipe_id'];
        $atividadeColetiva->usuario_ocupacao_id = $profissional['ocupacao_id'];
        $atividadeColetiva->data_usuario_responsavel = $cadastro['data_cadastro'];

        $procedimento = array_merge(request()->procedimentos, request()->procedimentos_individuais);

        $atividadeColetiva->procedimento_coletivo_id = request()->procedimento_coletivo_id;

        $atividadeColetiva->save();

        $participante = Participante::where('atividade_coletiva_id', $atividadeColetiva->id)->pluck('id')->toArray();

        DB::table('integracao_esus_inconsistencia_atividade_coletiva_participante')
            ->whereIn('atividade_coletiva_participante_id', $participante)
            ->delete();

        Participante::where('atividade_coletiva_id', $atividadeColetiva->id)->delete();

        self::saveParticipantes(request()->participantes, $atividadeColetiva);

        Procedimento::where('atividade_coletiva_id', $atividadeColetiva->id)->delete();
        self::saveProcedimento($procedimento, $atividadeColetiva);

        $atividadeColetiva->publicoAlvo()->sync(request()->publico_alvo);
        $atividadeColetiva->reuniaoTemas()->sync(request()->reuniao_temas);
        $atividadeColetiva->saudePratica()->sync(request()->saude_pratica);
        $atividadeColetiva->saudeTemas()->sync(request()->saude_temas);

        Profissional::where('atividade_coletiva_id', $atividadeColetiva->id)->delete();
        self::saveProfissionais(request()->profissionais, $atividadeColetiva);

        self::storeProcedimentos(request()->all(), $atividadeColetiva->id, $procedimento);
    }

    private static function storeProcedimentos($params, $atividadeColetivaId, $procedimentos) {

        $cadastro = $params['cadastro'];
        $profissional = $params['profissional'];
        $participantes = $params['participantes'];
        $procedimentosFicha = [];

        foreach ($procedimentos as $procedimento) {

            $procedimentosFicha[] = [
                'id' => $procedimento['procedimento_id'],
                'quantidade' => 1,
            ];
        }

        $ficha = [];

        foreach ($participantes as $participante) {

            $ficha[] = [
                'id' => null,
                'atendimento_individual_id' => null,
                'atividade_coletiva_id' => $atividadeColetivaId,
                'paciente_id' => $participante['id'],
                'data_usuario_responsavel' => $cadastro['data_cadastro'],
                'equipe_id' => $profissional['equipe_id'],
                'ocupacao_id' => $profissional['ocupacao_id'],
                'usuario_id' => $profissional['usuario']['id'],
                'local_atendimento_id' => LocalAtendimento::UBS,
                'afericao_pa' => null,
                'altura' => $participante['altura'],
                'tipo_atendimento_id' => null,
                'curativo' => null,
                'exame_laboratorial' => null,
                'glicemia' => null,
                'teste_rapido' => null,
                'procedimento_pequena_cirurgia' => null,
                'administracao_medicamento' => null,
                'peso' => $participante['peso'],
                'temperatura' =>  null,
                'microarea_id' =>  null,
                'escuta_inicial' =>  null,
                'turno_id' => $cadastro['turno_id'],
                'procedimentos' => $procedimentosFicha,
            ];
        }

        $atendimento = [
            'id' => null,
            'origem' => 'atividade_coletiva',
            'cadastro' => [
                'data_usuario_responsavel' => $cadastro['data_cadastro'],
                'equipe_id' => $profissional['equipe_id'],
                'ocupacao_id' => $profissional['ocupacao_id'],
                'usuario_id' => $profissional['usuario']['id'],
            ],
            'atendimentos' => $ficha,
            'procedimento_consolidado' => [
                'afericao_pa' => null,
                'altura' => null,
                'curativo' => null,
                'exame_laboratorial' => null,
                'glicemia_capilar' => null,
                'peso' => null,
                'temperatura' => null,
            ]
        ];

       $cbo = Ocupacao::find($profissional['ocupacao_id'])->codigo;

       $CboPermissao = OutrosPermissaoEsus::where('permissao_id', OutrasPermissoesEsusEnum::PROCEDIMENTOS)
            ->where('codigo', $cbo)
            ->exists();

        if ($CboPermissao && !empty($procedimentosFicha)) {

            ProcedimentoService::saveStore($atendimento);
        }
    }

    private static function saveProfissionais($profissionais, $atividadeColetiva) {

        foreach ($profissionais as $prof) {

            $profissional = Profissional::where('usuario_id', $prof['profissional_id'])
                ->where('atividade_coletiva_id', $atividadeColetiva->id)
                ->first() ?? new Profissional();

            $profissional->usuario_id = $prof['profissional_id'];
            $profissional->atividade_coletiva_id = $atividadeColetiva->id;
            $profissional->usuario_ocupacao_id = $prof['ocupacao_id'];
            $profissional->data_usuario_responsavel = $atividadeColetiva['data_usuario_responsavel'];
            $profissional->save();
        }
    }

    private static function saveParticipantes($participantes, $atividadeColetiva) {

        foreach ($participantes as $participante) {

            $paciente = Participante::where('paciente_id', $participante['id'])
                ->where('atividade_coletiva_id', $atividadeColetiva->id)
                ->first() ?? new Participante();

            $paciente->paciente_id = $participante['id'];
            $paciente->atividade_coletiva_id = $atividadeColetiva->id;
            $paciente->peso = $participante['peso'];
            $paciente->altura = $participante['altura'];
            $paciente->avaliacao_alterada = $participante['avaliacao_alterada'] == 'Sim' ? true : false;
            $paciente->parou_de_fumar = $participante['parou_fumar'] == 'Sim' ? true : false;
            $paciente->abandonou_grupo = $participante['abandonou_grupo'] == 'Sim' ? true : false;
            $paciente->save();
        }
    }

    private static function saveProcedimento($procedimentos, $atividadeColetiva) {

        foreach ($procedimentos as $proc) {

            $procedimento = Procedimento::where('procedimento_id', $proc['procedimento_id'])
                ->where('atividade_coletiva_id', $atividadeColetiva->id)
                ->first() ?? new Procedimento();

            $procedimento->procedimento_id = $proc['procedimento_id'];
            $procedimento->atividade_coletiva_id = $atividadeColetiva->id;
            $procedimento->paciente_id = !isset($proc['paciente_id']) ? null : $proc['paciente_id'];
            $procedimento->procedimento_padrao = !isset($proc['paciente_id']) ? true : false;
            $procedimento->save();
        }
    }

    private static function validate()
    {

        return request()->validate([
            'cadastro.data_cadastro' => [
                'required',
                'date',
            ],
            'cadastro.pse_id' => [
                'nullable',
                'integer',
            ],
            'cadastro.inep' => [
                'nullable',
                'required_if:cadastro.pse_id,1,2',
                'string',
                'max:8'
            ],
            'cadastro.local_atividade' => [
                'nullable',
                'string',
                'max:250'
            ],
            'cadastro.cnes' => [
                'nullable',
                'string'
            ],
            'cadastro.turno_id' => [
                'required',
                'integer',
            ],
            'profissional.usuario.id' => [
                'required',
                'integer',
                Rule::exists(Usuario::class, 'id'),
            ],
            'profissional.unidade_id' => [
                'required',
                'integer',
                Rule::exists(Unidade::class, 'id'),
            ],
            'profissional.infraestrutura_id' => [
                'required',
                'integer',
                Rule::exists(Infraestrutura::class, 'id'),
            ],
            'profissional.equipe_id' => [
                'required',
                'integer',
                Rule::exists(Equipe::class, 'id'),
            ],
            'profissional.ocupacao_id' => [
                'required',
                'integer',
                Rule::exists(Ocupacao::class, 'id'),
            ],
            'profissionais.usuario.id' => [
                'nullable',
                'integer',
                Rule::exists(Usuario::class, 'id'),
            ],
            'profissionais.ocupacao_id' => [
                'nullable',
                'integer',
                Rule::exists(Ocupacao::class, 'id'),
            ],
            'atividade.atividade_tipo_id' => [
                'required',
                'integer',
            ],
            'atividade.total_participantes' => [
                'required',
                'integer',
            ],
            'atividade.avaliacoes_alteradas' => [
                'nullable',
                'integer',
                'max:999'
            ],
            'participantes' => [
                'nullable',
                'required_if:atividade.atividade_tipo_id,5,6',
                'array'
            ],
            'reuniao_temas' => [
                'nullable',
                'required_if:atividade.atividade_tipo_id,1,2,3',
                'array',
                'max:7'
            ],
            'publico_alvo' => [
                'nullable',
                'required_if:atividade.atividade_tipo_id,4,5,6,7',
                'array',
                'max:17'
            ],
            'saude_temas' => [
                'nullable',
                'required_if:atividade.atividade_tipo_id,4,5,7',
                'array',
                'max:16'
            ],
            'saude_pratica' => [
                'nullable',
                'required_if:atividade.atividade_tipo_id,6',
                'array',
                'max:7'
            ],
        ]);
    }
}