<?php

namespace App\Http\Controllers\Cadastro\SujeitoAtencao;

use App\Enums\Cadastro\SujeitoAtencao\TipoRegistroUsuario;
use App\Http\Controllers\Controller;
use App\Http\Requests\Cadastro\SujeitoAtencao\UsuarioRequest;
use App\Mail\UsuarioLogin;
use App\Models\Cadastro\Estabelecimento\Unidade;
use App\Models\Cadastro\Parametrizacao\ParametrizacaoPermissaoOcupacao;
use App\Models\Cadastro\SujeitoAtencao\Lotacao;
use App\Models\Cadastro\SujeitoAtencao\Sexo;
use App\Models\Cadastro\SujeitoAtencao\Usuario;
use App\Models\Cadastro\SujeitoAtencao\UsuarioAssinatura;
use App\Models\Cadastro\SujeitoAtencao\UsuarioHistoricoAcesso;
use App\Models\Cadastro\SujeitoAtencao\UsuarioRegistroTipo;
use App\Models\Cns\TermoInvalido;
use App\Models\Intranet\Estado;
use App\Services\Cadastro\SujeitoAtencao\CidadaoService;
use App\Services\Cadastro\SujeitoAtencao\UsuarioService;
use App\Services\Integracao\IntegracaoCidadaoService;
use App\Utils\DataUtil;
use App\Utils\Email;
use App\Utils\Senha;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Http\Response;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Str;

class UsuarioController extends Controller
{
    protected $modulo = 'cadastro';
    protected $funcionalidade = 'usuario';

    public static function datatable()
    {
        $showNaoRegularizados = DataUtil::isStringBoolean(request()->get('showNaoRegularizados'))
            && DataUtil::getBooleanValueFromStringBoolean(request()->get('showNaoRegularizados'));

        $usuarios = DB::table('cadastro_usuario')
            ->select(
                'cadastro_usuario.id',
                'cadastro_cidadao.nome',
                'cadastro_cidadao.cpf',
                'cadastro_cidadao.cns',
                'cadastro_usuario.bloqueado',
                DB::raw('
                        DATE_FORMAT(cadastro_cidadao.data_nascimento, "%d/%m/%Y") as data_nascimento
                    '),
                'cadastro_usuario.email',
                DB::raw("
                    (
                        SELECT      TRUE
                        FROM        cadastro_obito
                        WHERE       cadastro_obito.cidadao_id = cadastro_cidadao.id
                        AND         cadastro_obito.deleted_at IS NULL
                        LIMIT       1
                    ) AS obito
                ")
            )
            ->join('cadastro_cidadao', 'cadastro_cidadao.id', 'cadastro_usuario.cidadao_id')
            ->whereNull('cadastro_usuario.deleted_at')
            ->when($showNaoRegularizados, function ($query) {

                $query->whereNull('cadastro_cidadao.cns');
            })
            ->when(!$showNaoRegularizados, function ($query) {

                $query->whereNotNull('cadastro_cidadao.cns');
            });

        return datatables()
            ->of($usuarios)
            ->filterColumn('cadastro_cidadao.cpf', function ($query, $keyword) {

                $query
                    ->whereRaw("cadastro_cidadao.cpf like ?", ["%{$keyword}%"])
                    ->orWhereRaw(
                        "CONCAT(
                            SUBSTR(cadastro_cidadao.cpf,1,3),
                            '.',
                            SUBSTR(cadastro_cidadao.cpf,4,3),
                            '.',
                            SUBSTR(cadastro_cidadao.cpf,7,3),
                            '-',
                            SUBSTR(cadastro_cidadao.cpf,10,2)
                        ) like ?",
                        ["%{$keyword}%"]
                    );
            })
            ->skipTotalRecords()
            ->toJson();
    }

    public function index()
    {
        $this->auth(__FUNCTION__);

        $usuarios = $this->get(Usuario::class)->get();

        return response()->json($usuarios, Response::HTTP_OK);
    }

    public function create()
    {
        $this->auth(__FUNCTION__);

        return response()->json(
            [
                'form' => $this->getFormData(),
            ],
            Response::HTTP_OK
        );
    }

    public function store(UsuarioRequest $request)
    {
        $this->auth(__FUNCTION__);

        $usuario = $this->save($request->all());

        return response()->json($usuario->fresh(), Response::HTTP_CREATED);
    }

    public function assinatura(Request $request)
    {
        return response()->json(UsuarioService::assinatura($request), Response::HTTP_CREATED);
    }

    public function destroyAssinatura($id)
    {
        return response()->json(UsuarioService::destroyAssinatura($id), Response::HTTP_NO_CONTENT);
    }

    public function loadAssinatura($id)
    {

        return response()->json(
            [
                'form' => [],
                'model' => [
                    'assinatura' => UsuarioAssinatura::where('usuario_id', $id)
                        ->get()
                        ->map(fn ($unidade) => [
                                'id' => $unidade->id ?? null,
                                'arquivo' => $unidade->arquivo ?? null,
                            ])
                        ->values(),
                ],
            ],
            Response::HTTP_OK
        );
    }

    public function downloadAssinatura($id)
    {

        $response = UsuarioService::downloadAssinatura($id);

        $headers = [
            'Content-Type' => 'application/png',
        ];

        return response()->download($response['arquivo'], $response['nome'], $headers);
    }

    public function show($id)
    {
        $this->auth(__FUNCTION__);

        $usuario = $this->get(Usuario::class, $id);

        if (request()->query('with') && $this->hasRelationOnWith('lotacoes.infraestrutura.unidade')) {

            $usuario->lotacoes->each(fn ($l) => $l->infraestrutura->makeVisible('unidade'));
        }

        return response()->json($usuario, Response::HTTP_OK);
    }

    private function hasRelationOnWith($relation)
    {
        $with = request()->query('with');

        return (is_array($with) && in_array($relation, $with))
            || (is_string($with) && $with === $relation);
    }

    public function edit($id)
    {
        $this->auth(__FUNCTION__);

        $usuario = Usuario::findOrFail($id);

        return response()->json(
            [
                'form' => array_merge(
                    ['cidadao' => CidadaoService::edit($usuario->cidadao_id)['form']],
                    $this->getFormData()
                ),
                'model' => [
                    'documentos' => [
                        'conselho_profissional' => [
                            'registro_tipo_id' => $usuario->registro_tipo_id,
                            'registro_tipo_outro' => $usuario->registro_tipo_outro,
                            'registro_numero' => $usuario->registro_numero,
                            'registro_estado_id' => $usuario->registro_estado_id,
                        ],
                    ],
                    'lotacoes' => $usuario->lotacoes->map(fn ($lotacao) => [
                        'id' => $lotacao->id,
                        'unidade_id' => $lotacao->infraestrutura->unidade_id,
                        'unidade_nome' => $lotacao->infraestrutura->unidade->nome_fantasia,
                        'infraestrutura_id' => $lotacao->infraestrutura_id,
                        'infraestrutura_nome' => $lotacao->infraestrutura->nome,
                        'ocupacao' => $lotacao->ocupacao,
                        'realiza_atendimento' => $lotacao->realiza_atendimento,
                        'disabled' => !$lotacao->is_allowed_to_delete,
                        'principal' => $lotacao->principal,
                        'ativo' => $lotacao->ativo,
                        'centros_custo' => $lotacao->centrosCusto->map(fn ($centroCusto) => [
                            'id' => $centroCusto->id,
                            'nome' => $centroCusto->setor->nome,
                        ]),
                    ]),
                    'email' => $usuario->email,
                    'usuario' => $usuario->usuario,
                    'cidadao' => array_merge([
                        'id' => $usuario->cidadao_id,
                    ], CidadaoService::edit($usuario->cidadao_id)['model']),
                ],
            ],
            Response::HTTP_OK
        );
    }

    private function getFormData()
    {

        return [
            'termos_invalidos' => TermoInvalido::all()->map(fn ($termo) => $termo->descricao),
            'data_atual' => Carbon::now()->format('d/m/Y'),
            'is_permissao_endereco' => true,
            'documentos' => [
                'conselho_profissional' => [
                    'tipos_registro' => UsuarioRegistroTipo::orderBy('descricao')->get()->map(fn ($tipo) => [
                        'id' => $tipo->id,
                        'descricao' => $tipo->sigla ? "{$tipo->sigla} - {$tipo->descricao}" : $tipo->descricao
                    ]),
                    'estados' => Estado::orderBy('nome')->get()->map(fn ($estado) => [
                        'id' => $estado->id,
                        'uf' => $estado->uf
                    ]),
                ],
            ],
            'lotacao' => [
                'unidades' => Unidade::orderBy('nome_fantasia')->get()->map(fn ($unidade) => [
                    'id' => $unidade->id,
                    'nome_fantasia' => $unidade->nome_fantasia,
                    'infraestruturas' => $unidade->infraestruturas->sortBy('nome')->map(fn ($infraestrutura) => [
                        'id' => $infraestrutura->id,
                        'nome' => $infraestrutura->nome,
                    ])->values()
                ]),
            ],
            'sexos' => Sexo::orderBy('descricao')->get()->map(fn ($sexo) => [
                'id' => $sexo->id,
                'descricao' => $sexo->descricao
            ]),
        ];
    }

    public function update(UsuarioRequest $request, $id)
    {
        $this->auth(__FUNCTION__);

        $usuario = $this->save($request->all(), (Usuario::findOrFail($id))->id);

        return response()->json($usuario->fresh(), Response::HTTP_OK);
    }

    private function save($params, $id = null)
    {
        $usuario = null;

        DB::transaction(function () use (&$usuario, $params, $id) {

            $cidadao = CidadaoService::save($params['cidadao']);

            $data = $this->getPreparedData($params, $id);
            $data['cidadao_id'] = $cidadao->id;

            $usuario = Usuario::updateOrCreate(
                ['id' => $id],
                $data
            );

            $this->deleteLotacoesNotPresent($usuario, $data['lotacoes']);
            $this->saveLotacoes($usuario, $data['lotacoes']);

            if ($usuario !== null && $id === null && !empty($data['email'])) {

                $object = new \stdClass();
                $object->user = $usuario->usuario;
                $object->password = $data['senha'];
                $object->cliente = request()->header('customer');

                Email::enviar($data['email'], new UsuarioLogin($object));
            }

            if (!$params['cidadao']['cadastro_simplificado']) {

                IntegracaoCidadaoService::integrar($cidadao->id, 'usuario');
                IntegracaoCidadaoService::integrar($cidadao->id, 'paciente');
            }
        });

        return $usuario;
    }

    private function getPreparedData($params, $id = null)
    {
        $partName = Str::substr(preg_replace('/\s+/', '', $params['cidadao']['nome']), -3);
        $partTimestamp = Str::substr(Carbon::now()->timestamp, -6);

        $usuario = $params['cidadao']['cadastro_simplificado']
            ? "{$partName}{$partTimestamp}"
            : $params['usuario'];

        $data = [
            'registro_tipo_id' => $params['documentos']['conselho_profissional']['registro_tipo_id'] ?? null,
            'registro_tipo_outro' => $params['documentos']['conselho_profissional']['registro_tipo_outro'] ?? null,
            'registro_numero' => $params['documentos']['conselho_profissional']['registro_numero'] ?? null,
            'registro_estado_id' => $params['documentos']['conselho_profissional']['registro_estado_id'] ?? null,
            'email' => $params['email'] ?? null,
            'usuario' => $usuario,
            'lotacoes' => $params['lotacoes'] ?? [],
        ];

        if ($id === null) {

            $data['senha'] = Senha::gerar();
            $data['troca_senha'] = true;
        }

        if ($data['registro_tipo_id'] !== TipoRegistroUsuario::OUTRO) {

            $data['registro_tipo_outro'] = null;
        }

        if (is_string($data['registro_tipo_outro'])) {

            $data['registro_tipo_outro'] = mb_strtoupper($data['registro_tipo_outro']);
        }

        if (is_string($data['registro_numero'])) {

            $data['registro_numero'] = mb_strtoupper($data['registro_numero']);
        }

        return $data;
    }

    private function deleteLotacoesNotPresent($usuario, $lotacoes)
    {
        $ids = collect($lotacoes)->pluck('id')->filter(fn ($id) => !is_null($id))->toArray();

        Lotacao::destroy($usuario->lotacoes()->whereNotIn('id', $ids)->pluck('id'));
    }

    private function saveLotacoes($usuario, $lotacoes)
    {
        foreach ($lotacoes as $lotacaoData) {
            $lotacao = $usuario->lotacoes()->updateOrCreate(
                ['id' => $lotacaoData['id'] ?? null],
                $lotacaoData
            );

            $lotacao->centrosCusto()->sync($lotacaoData['centros_custo'] ?? []);
        }
    }

    public function destroy($id)
    {
        $this->auth(__FUNCTION__);

        Usuario::findOrFail($id)->delete();

        return response()->json(null, Response::HTTP_NO_CONTENT);
    }

    public function gerarSenha($id)
    {
        $this->auth(__FUNCTION__);

        $usuario = Usuario::findOrFail($id);

        if ($usuario) {
            $senha = Senha::gerar();

            $params = [
                'senha' => $senha,
                'troca_senha' => true,
            ];

            $usuario->update($params);

            $object = new \stdClass();
            $object->user = $usuario->usuario;
            $object->password = $senha;
            $object->cliente = request()->header('customer');

            Email::enviar($usuario->email, new UsuarioLogin($object));
        }

        return response()->json($usuario->fresh(), Response::HTTP_OK);
    }

    public function bloquear($id)
    {
        $this->auth(__FUNCTION__);

        $usuario = Usuario::findOrFail($id);

        $usuario->update(['bloqueado' => true]);

        return response()->json($usuario->fresh(), Response::HTTP_OK);
    }

    public function desbloquear($id)
    {
        $this->auth(__FUNCTION__);

        $usuario = Usuario::findOrFail($id);

        $usuario->update(['bloqueado' => false]);

        UsuarioHistoricoAcesso::where('usuario_id', $usuario->id)->update(['ativo' => false]);

        return response()->json($usuario->fresh(), Response::HTTP_OK);
    }

    public function autocomplete()
    {
        return datatables()->of(UsuarioService::autocomplete())->toJson();
    }

    public function lotacoes($id, Request $request)
    {
        if(!$id) {
            return null;
        }

        $data = Lotacao::where('usuario_id', $id)
                    ->get()
                    ->map(fn ($lotacao) => [
                        'id' => $lotacao->id,
                        'unidade' => $lotacao->infraestrutura->nome,
                        'codigo' => $lotacao->ocupacao->codigo,
                        'ocupacao' => $lotacao->ocupacao->nome,
                ]);

        return response()->json($data, Response::HTTP_OK);
    }

    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
                "),
                'atencao_basica_parametrizacao_microarea.id as microarea_id'
            ])
            ->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',
                DB::raw("CONCAT(TRIM(cadastro_unidade.cnes), ' - ',  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()
            ->orderBy('cadastro_unidade.cnes')
            ->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);

        $ocupacaoSelecionada = request()->ocupacao_id;

        return $usuario->lotacoes
            ->filter(function ($lotacao) use ($ocupacaoSelecionada) {
                return $lotacao->infraestrutura->id == request()->infraestrutura_id
                    && (
                        $lotacao->ativo
                        || $lotacao->ocupacao_id == $ocupacaoSelecionada
                    );
            })
            ->pluck('ocupacao');
    }

    public function getCentrosCusto()
    {
        return DB::table('cadastro_centro_custo')
            ->select([
                'cadastro_centro_custo.id',
                'cadastro_setor.nome',
            ])
            ->join('cadastro_setor', 'cadastro_setor.id', '=', 'cadastro_centro_custo.setor_id')
            ->where('infraestrutura_id', request()->infraestrutura_id)
            ->whereNull('cadastro_centro_custo.deleted_at')
            ->orderBy('cadastro_setor.nome')
            ->get();
    }
}