rkm-conectasus-ci-sandbox/api/app/Services/Manutencao/GerenciamentoService.php

<?php

namespace App\Services\Manutencao;

use App\Enums\Manutencao\StatusTipo as StatusEnum;
use App\Models\Cadastro\Material\Material as MaterialModel;
use App\Models\Cadastro\ServicoManutencao;
use App\Models\Cadastro\ServicoManutencaoCausasProvaveis;
use App\Models\Cadastro\ServicoManutencaoPrestadorFornecedor;
use App\Models\Cadastro\UnidadeExecutanteManutencao;
use App\Models\Manutencao\GerenciamentoMensagem;
use App\Models\Manutencao\Solicitacao;
use App\Models\Manutencao\SolicitacaoCausaProvavel;
use App\Models\Manutencao\SolicitacaoItensAlmoxarifado;
use App\Models\Manutencao\SolicitacaoMensagem;
use App\Models\Manutencao\SolicitacaoResposta;
use App\Models\Manutencao\SolicitacaoStatusHistorico;
use App\Models\Manutencao\Status;
use App\Services\Service;
use Carbon\Carbon;
use DB;
use Illuminate\Validation\Rule;

class GerenciamentoService extends Service
{
    public static function datatable()
    {
        $periodo = self::getPeriodo();

        $solicitacoes = DB::table('manutencao_solicitacao as solicitacao')
            ->join('cadastro_servico_manutencao as servico', 'servico.id', 'solicitacao.servico_id')
            ->leftJoin('cadastro_grupo as grupo', 'grupo.id', 'servico.grupo_id')
            ->leftJoin('cadastro_subgrupo as subgrupo', 'subgrupo.id', 'solicitacao.subgrupo_id')
            ->join('manutencao_parametrizacao_status', 'manutencao_parametrizacao_status.id', 'solicitacao.status_id')
            ->join('manutencao_status_tipo as status', 'status.id', 'manutencao_parametrizacao_status.tipo_id')
            ->leftJoin('manutencao_prioridade_tipo as prioridade', 'prioridade.id', 'servico.prioridade_id')
            ->join('cadastro_usuario as usuario', 'usuario.id', 'solicitacao.usuario_solicitante_id')
            ->join('cadastro_cidadao as cidadao', 'cidadao.id', 'usuario.cidadao_id')
            ->join('cadastro_infraestrutura as infraestrutura', 'infraestrutura.id', 'solicitacao.infraestrutura_solicitante_id')
            ->where('solicitacao.created_at', '>=', $periodo['data_inicial'])
            ->where('solicitacao.created_at', '<=', $periodo['data_final'])
            ->selectRaw('
                DATE_FORMAT(solicitacao.created_at, "%d/%m/%Y") as data,
                solicitacao.id as id,
                grupo.nome as grupo,
                subgrupo.nome as subgrupo,
                servico.nome as servico,
                status.nome as status,
                prioridade.nome as prioridade,
                solicitacao.codigo as codigo,
                cidadao.nome as usuario_solicitante,
                solicitacao.assunto as assunto,
                status.id as status_id,
                (
                    SELECT CASE
                        WHEN COUNT(*) > 1 AND (
                            SELECT status.nome
                            FROM manutencao_solicitacao_status_historico as status_historico
                            JOIN manutencao_status_tipo as status ON status.id = status_historico.status_id
                            WHERE status_historico.solicitacao_id = solicitacao.id
                            ORDER BY status_historico.created_at DESC
                            LIMIT 1
                        ) != "Cancelado"
                        AND solicitacao.pendente_finalizacao != true
                        THEN true
                        ELSE false
                    END
                    FROM manutencao_solicitacao_status_historico as status_historico
                    WHERE status_historico.solicitacao_id = solicitacao.id
                ) as allow_cancel,
                solicitacao.pendente_finalizacao as pendente_finalizacao
            ')
            ->distinct();

        $solicitacoes = self::getQueryParams($solicitacoes);
        $solicitacoes = $solicitacoes->get();

        $mensagens = DB::table('manutencao_gerenciamento_mensagem')
            ->leftJoin('manutencao_solicitacao_resposta', 'manutencao_gerenciamento_mensagem.id', 'manutencao_solicitacao_resposta.mensagem_id')
            ->leftJoin('cadastro_usuario as usuario_mensagem', 'manutencao_gerenciamento_mensagem.usuario_id', 'usuario_mensagem.id')
            ->leftJoin('cadastro_cidadao as cidadao_mensagem', 'usuario_mensagem.cidadao_id', 'cidadao_mensagem.id')
            ->leftJoin('cadastro_usuario as usuario_resposta', 'manutencao_solicitacao_resposta.usuario_id', 'usuario_resposta.id')
            ->leftJoin('cadastro_cidadao as cidadao_resposta', 'usuario_resposta.cidadao_id', 'cidadao_resposta.id')
            ->selectRaw('
                manutencao_gerenciamento_mensagem.solicitacao_id,
                manutencao_gerenciamento_mensagem.id as mensagem_id,
                manutencao_gerenciamento_mensagem.mensagem as mensagem_conteudo,
                manutencao_gerenciamento_mensagem.created_at as mensagem_data_envio,
                manutencao_solicitacao_resposta.id as resposta_id,
                manutencao_solicitacao_resposta.mensagem as resposta_conteudo,
                manutencao_solicitacao_resposta.created_at as resposta_data_envio,
                cidadao_resposta.nome as resposta_usuario_nome,
                cidadao_mensagem.nome as mensagem_usuario_nome
            ')
            ->get()
            ->groupBy('solicitacao_id');

        $solicitacoes->each(function ($item) use ($mensagens) {
            $item->mensagens_resposta = $mensagens->get($item->id, collect())
                ->sortByDesc('mensagem_data_envio')
                ->map(function ($mensagem) {
                    return [
                        'mensagem' => [
                            'mensagem_id' => $mensagem->mensagem_id,
                            'mensagem_conteudo' => $mensagem->mensagem_conteudo,
                            'mensagem_data' => $mensagem->mensagem_data_envio
                                ? Carbon::parse($mensagem->mensagem_data_envio)->format('d/m/Y') : null,
                            'mensagem_hora' => $mensagem->mensagem_data_envio
                                ? Carbon::parse($mensagem->mensagem_data_envio)->format('H:i') : null,
                            'mensagem_usuario' => $mensagem->mensagem_usuario_nome,
                        ],
                        'resposta' => $mensagem->resposta_id ? [
                            'resposta_id' => $mensagem->resposta_id,
                            'resposta_mensagem' => $mensagem->resposta_conteudo,
                            'resposta_data' => $mensagem->resposta_data_envio
                                ? Carbon::parse($mensagem->resposta_data_envio)->format('d/m/Y') : null,
                            'resposta_hora' => $mensagem->resposta_data_envio
                                ? Carbon::parse($mensagem->resposta_data_envio)->format('H:i') : null,
                            'resposta_usuario' => $mensagem->resposta_usuario_nome,
                        ] : null,
                    ];
                })
            ->values()
            ->toArray();
        });

        return $solicitacoes->toArray();
    }

    public static function list()
    {
        $camposParaCarregar = collect();

        $camposParaCarregar->push(
            'servico',
            'unidade',
            'infraestrutura',
            'grupo',
            'subgrupo',
            'status',
            'prioridade',
        );

        return [
            'model' => self::getModelData(),
            'form' => self::camposFiltrados($camposParaCarregar),
            'additionals' => self::getAdditionalsData(),
        ];
    }

    private static function camposFiltrados($campos)
    {
        $dados = collect();

        if ($campos->contains('servico')) {
            $dados->put('servicos', self::getServicos());
        }

        if ($campos->contains('unidade')) {
            $dados->put('unidades', self::getUnidadesSolicitantes());
        }

        if ($campos->contains('infraestrutura')) {
            $dados->put('infraestruturas', self::getInfraestruturasSolicitantes());
        }

        if ($campos->contains('grupo')) {
            $dados->put('grupos', self::getGrupos());
        }

        if ($campos->contains('subgrupo')) {
            $dados->put('subgrupos', self::getSubgrupos());
        }

        if ($campos->contains('status')) {
            $dados->put('status', self::getStatus());
        }

        if ($campos->contains('prioridade')) {
            $dados->put('prioridades', self::getPrioridade());
        }

        return $dados->all();
    }

    private static function getModelData()
    {
        return [
            'periodo' => [
                'date' => [
                    'start' => null,
                    'end' => null
                ]
            ],
            'usuario_solicitante_id' => null,
            'unidades_solicitantes_id' => null,
            'infraestruturas_solicitantes_id' => null,
            'grupos_id' => null,
            'subgrupos_id' => null,
            'servicos_id' => null,
            'status_id' => null,
            'prioridade_id' => null,
        ];
    }

    private static function getFormData()
    {

        return [
            'unidades_solicitantes' => self::getUnidadesSolicitantes(),
            'infraestruturas_solicitantes' => self::getInfraestruturasSolicitantes(),
            'grupos' => self::getGrupos(),
            'subgrupos' => self::getSubgrupos(),
            'servicos' => self::getServicos(),
            'status' => self::getStatus(),
            'prioridades' => self::getPrioridade(),
        ];
    }

    private static function getAdditionalsData()
    {
        return [
            'data_atual' => Carbon::today()->format('d/m/Y'),
        ];
    }

    private static function getPeriodo()
    {

        $periodo = request()->get('periodo') ?? null;

        if ($periodo && $periodo['date']['start'] && $periodo['date']['end']) {

            $dataInicial = Carbon::createFromFormat('Y-m-d', $periodo['date']['start'])->startOfDay();
            $dataFinal = Carbon::createFromFormat('Y-m-d', $periodo['date']['end'])->endOfDay();
        } else {

            $dataInicial = Carbon::today()->startOfDay();
            $dataFinal = Carbon::today()->endOfDay();
        }

        return [
            'data_inicial' => $dataInicial,
            'data_final' => $dataFinal,
        ];

    }

    public static function autocompleteUsuarioSolicitante()
    {
        $periodo = request()->get('periodo');
        $startInicioDia = Carbon::createFromFormat('Y-m-d', $periodo['start'])->startOfDay();
        $endFinalDIa = Carbon::createFromFormat('Y-m-d', $periodo['end'])->endOfDay();

        $usuarios = DB::table('manutencao_solicitacao as solicitacao')
            ->join('cadastro_usuario as usuario', 'usuario.id', 'solicitacao.usuario_solicitante_id')
            ->join('cadastro_cidadao as cidadao', 'cidadao.id', 'usuario.cidadao_id')
            ->where('solicitacao.created_at', '>=', $startInicioDia)
            ->where('solicitacao.created_at', '<=', $endFinalDIa)
            ->distinct()
            ->selectRaw('
                usuario.id as id,
                cidadao.nome as nome_usuario_solicitante
            ');

        return $usuarios;
    }

    private static function getServicos()
    {
        $periodo = self::getPeriodo();

        $servicos = DB::table('manutencao_solicitacao as solicitacao')
            ->join('cadastro_servico_manutencao as servico', 'servico.id', 'solicitacao.servico_id')
            ->join('cadastro_infraestrutura as infraestrutura', 'infraestrutura.id', 'solicitacao.infraestrutura_solicitante_id')
            ->where('solicitacao.created_at', '>=', $periodo['data_inicial'])
            ->where('solicitacao.created_at', '<=', $periodo['data_final'])
            ->selectRaw('
                servico.id as id,
                servico.nome as nome_servico
            ');

        $servicos = self::getQueryParams($servicos);

        $servicos = $servicos
            ->distinct()
            ->get()
            ->toArray();

        $form = array_map(function ($servico) {
            return [
                'id' => $servico->id,
                'nome_servico' => $servico->nome_servico,
            ];
        }, $servicos);

        return $form;
    }

    private static function getUnidadesSolicitantes()
    {
        $periodo = self::getPeriodo();

        $unidades = DB::table('manutencao_solicitacao as solicitacao')
            ->join('cadastro_infraestrutura as infraestrutura', 'infraestrutura.id', 'solicitacao.infraestrutura_solicitante_id')
            ->join('cadastro_unidade as unidade', 'unidade.id',  'infraestrutura.unidade_id')
            ->join('cadastro_servico_manutencao as servico', 'servico.id', 'solicitacao.servico_id')
            ->where('solicitacao.created_at', '>=', $periodo['data_inicial'])
            ->where('solicitacao.created_at', '<=', $periodo['data_final'])
            ->selectRaw('
                unidade.id as id,
                unidade.nome_fantasia as nome_unidade_solicitante
            ');

        $unidades = self::getQueryParams($unidades);

        $unidades = $unidades
            ->distinct()
            ->get()
            ->toArray();

        $form = array_map(function ($unidade) {
            return [
                'id' => $unidade->id,
                'nome_unidade_solicitante' => $unidade->nome_unidade_solicitante,
            ];
        }, $unidades);

        return $form;
    }

    private static function getInfraestruturasSolicitantes()
    {
        $periodo = self::getPeriodo();

        $infraestruturas = DB::table('manutencao_solicitacao as solicitacao')
            ->join('cadastro_infraestrutura as infraestrutura', 'infraestrutura.id', 'solicitacao.infraestrutura_solicitante_id')
            ->join('cadastro_unidade as unidade', 'unidade.id',  'infraestrutura.unidade_id')
            ->join('cadastro_servico_manutencao as servico', 'servico.id', 'solicitacao.servico_id')
            ->where('solicitacao.created_at', '>=', $periodo['data_inicial'])
            ->where('solicitacao.created_at', '<=', $periodo['data_final'])
            ->selectRaw('
                infraestrutura.id as id,
                COALESCE(infraestrutura.nome, unidade.nome_fantasia) as nome_infraestrutura_solicitante
            ');

        $infraestruturas = self::getQueryParams($infraestruturas);

        $infraestruturas = $infraestruturas
            ->distinct()
            ->get()
            ->toArray();

        $form = array_map(function ($infraestrutura) {
            return [
                'id' => $infraestrutura->id,
                'nome_infraestrutura_solicitante' => $infraestrutura->nome_infraestrutura_solicitante,
            ];
        }, $infraestruturas);

        return $form;
    }

    private static function getGrupos()
    {
        $periodo = self::getPeriodo();

        $grupos = DB::table('manutencao_solicitacao as solicitacao')
            ->join('cadastro_servico_manutencao as servico', 'servico.id', 'solicitacao.servico_id')
            ->join('cadastro_grupo as grupo', 'grupo.id', 'servico.grupo_id')
            ->join('cadastro_infraestrutura as infraestrutura', 'infraestrutura.id', 'solicitacao.infraestrutura_solicitante_id')
            ->where('solicitacao.created_at', '>=', $periodo['data_inicial'])
            ->where('solicitacao.created_at', '<=', $periodo['data_final'])
            ->selectRaw('
                grupo.id as id,
                grupo.nome as nome_grupo
            ');

        $grupos = self::getQueryParams($grupos);

        $grupos = $grupos
            ->distinct()
            ->get()
            ->toArray();

        $form = array_map(function ($grupo) {
            return [
                'id' => $grupo->id,
                'nome_grupo' => $grupo->nome_grupo,
            ];
        }, $grupos);

        return $form;
    }

    private static function getSubgrupos()
    {
        $periodo = self::getPeriodo();

        $subgrupos = DB::table('manutencao_solicitacao as solicitacao')
            ->join('cadastro_subgrupo as subgrupo', 'subgrupo.id', 'solicitacao.subgrupo_id')
            ->join('cadastro_servico_manutencao as servico', 'servico.id', 'solicitacao.servico_id')
            ->join('cadastro_infraestrutura as infraestrutura', 'infraestrutura.id', 'solicitacao.infraestrutura_solicitante_id')
            ->where('solicitacao.created_at', '>=', $periodo['data_inicial'])
            ->where('solicitacao.created_at', '<=', $periodo['data_final'])
            ->selectRaw('
                subgrupo.id as id,
                subgrupo.nome as nome_subgrupo
            ');

        $subgrupos = self::getQueryParams($subgrupos);

        $subgrupos = $subgrupos
            ->distinct()
            ->get()
            ->toArray();

        $form = array_map(function ($subgrupo) {
            return [
                'id' => $subgrupo->id,
                'nome_subgrupo' => $subgrupo->nome_subgrupo,
            ];
        }, $subgrupos);

        return $form;
    }

    private static function getStatus()
    {
        $periodo = self::getPeriodo();

        $status = DB::table('manutencao_solicitacao as solicitacao')
            ->join('manutencao_parametrizacao_status', 'manutencao_parametrizacao_status.id', 'solicitacao.status_id')
            ->join('manutencao_status_tipo as status', 'status.id', 'manutencao_parametrizacao_status.tipo_id')
            ->join('cadastro_infraestrutura as infraestrutura', 'infraestrutura.id', 'solicitacao.infraestrutura_solicitante_id')
            ->join('cadastro_servico_manutencao as servico', 'servico.id', 'solicitacao.servico_id')
            ->where('solicitacao.created_at', '>=', $periodo['data_inicial'])
            ->where('solicitacao.created_at', '<=', $periodo['data_final'])
            ->selectRaw('
                manutencao_parametrizacao_status.id as id,
                manutencao_parametrizacao_status.nome as nome
            ');

        $status = self::getQueryParams($status);

        $status = $status
            ->distinct()
            ->get()
            ->toArray();

        $form = array_map(function ($status) {
            return [
                'id' => $status->id,
                'nome' => $status->nome,
            ];
        }, $status);

        return $form;
    }

    private static function getPrioridade()
    {
        $periodo = self::getPeriodo();

        $prioridades = DB::table('manutencao_solicitacao as solicitacao')
            ->join('cadastro_servico_manutencao as servico', 'servico.id', 'solicitacao.servico_id')
            ->join('manutencao_prioridade_tipo as prioridade', 'prioridade.id', 'servico.prioridade_id')
            ->join('cadastro_infraestrutura as infraestrutura', 'infraestrutura.id', 'solicitacao.infraestrutura_solicitante_id')
            ->where('solicitacao.created_at', '>=', $periodo['data_inicial'])
            ->where('solicitacao.created_at', '<=', $periodo['data_final'])
            ->selectRaw('
                prioridade.id as id,
                prioridade.nome as nome_prioridade
            ');

        $prioridades = self::getQueryParams($prioridades);

        $prioridades = $prioridades
            ->distinct()
            ->get()
            ->toArray();

        $form = array_map(function ($prioridade) {
            return [
                'id' => $prioridade->id,
                'nome_prioridade' => $prioridade->nome_prioridade,
            ];
        }, $prioridades);

        return $form;
    }

    private static function getQueryParams($query)
    {

        $params = request()->all();

        if (isset($params['usuario_solicitante_id']) && !empty($params['usuario_solicitante_id'])) {
            $query->where('solicitacao.usuario_solicitante_id', $params['usuario_solicitante_id'] ?? $params['usuario_solicitante_id']['id']);
        }

        if (isset($params['servicos_id']) && is_array($params['servicos_id'])) {
            $query->whereIn('solicitacao.servico_id', $params['servicos_id']);
        }

        if (isset($params['unidades_solicitantes_id']) && is_array($params['unidades_solicitantes_id'])) {
            $query->whereIn('infraestrutura.unidade_id', $params['unidades_solicitantes_id']);
        }

        if (isset($params['infraestruturas_solicitantes_id']) && is_array($params['infraestruturas_solicitantes_id'])) {
            $query->whereIn('solicitacao.infraestrutura_solicitante_id', $params['infraestruturas_solicitantes_id']);
        }

        if (isset($params['grupos_id']) && is_array($params['grupos_id'])) {
            $query->whereIn('servico.grupo_id', $params['grupos_id']);
        }

        if (isset($params['subgrupos_id']) && is_array($params['subgrupos_id'])) {
            $query->whereIn('solicitacao.subgrupo_id', $params['subgrupos_id']);
        }

        if (isset($params['status_id']) && is_array($params['status_id'])) {

            $query->whereIn('solicitacao.status_id', $params['status_id']);
        }

        if (isset($params['prioridade_id']) && is_array($params['prioridade_id'])) {
            $query->whereIn('servico.prioridade_id', $params['prioridade_id']);
        }

        return $query;
    }

    public static function edit($id)
    {

        $solicitacao = Solicitacao::findOrFail($id);

        $statusParametrizacao = DB::table('manutencao_parametrizacao_status')
        ->where('id', $solicitacao->status_id)
        ->first();

        $statusTipoId = DB::table('manutencao_status_tipo')
            ->where('id', $statusParametrizacao->tipo_id)
            ->select('id')
            ->first();

        $data = [
            'additionals' => [
                'is_custo' => ServicoManutencao::find($solicitacao->servico_id)->is_custo,
                'is_agendamento_programado' => ServicoManutencao::find($solicitacao->servico_id)->is_agendamento_programado,
                'is_identifica_os_prestador' => ServicoManutencao::find($solicitacao->servico_id)->is_identifica_os_prestador,
                'is_identifica_itens_almoxarifado' => ServicoManutencao::find($solicitacao->servico_id)->is_identifica_itens_almoxarifado,
                'data_atual' => Carbon::today()->format('d/m/Y'),
            ],
            'model' => [
                'comentario_atual' => null,
                'prestador_id' => $solicitacao->prestador_id ?? null,
                'custo' => $solicitacao->custo ?? null,
                'data_agendamento' => $solicitacao->data_agendamento ? $solicitacao->data_agendamento->format('d/m/Y') : null,
                'os_prestador' => $solicitacao->os_prestador ?? null,
                'itens' => self::getItensAlmoxarifado($solicitacao->id) ?? [],
                'material' => null,
                'quantidade' => 1,
                'servico' => $solicitacao->servico->nome,
            ],
            'form' => [
                'additionals' => [],
                'assunto' => $solicitacao->assunto,
                'data_solicitacao' => $solicitacao->created_at->format('d/m/Y'),
                'detalhe' => $solicitacao->detalhe,
                'dias_solicitacao_aberto' => $solicitacao->created_at->diffInDays(Carbon::now()),
                'grupo' => $solicitacao->servico->grupo->nome,
                'infraestrutura_solicitante' => $solicitacao->infraestruturaSolicitante->nome ??
                    $solicitacao->infraestruturaSolicitante->unidade->nome_fantasia,
                'mensagens_reposposta' => self::getMensage($solicitacao),
                'prestadores' => self::getPrestadores($solicitacao['servico_id']),
                'servico' => $solicitacao->servico->nome,
                'subgrupo' => $solicitacao->subgrupo->nome,
                'unidade_solicitante' => $solicitacao->infraestruturaSolicitante->unidade->nome_fantasia,
                'usuario_solicitante' => $solicitacao->usuarioSolicitante->cidadao->nome,
                'pedente_finalizacao' => $solicitacao->pendente_finalizacao,
                'status_tipo_id' => $statusTipoId->id,$statusTipoId->id,
                'causas_provaveis' => self::getCausaProvavel($solicitacao->id) ?? null,
            ],
        ];

        return $data;
    }

    private static function getItensAlmoxarifado($id)
    {
        $itens = SolicitacaoItensAlmoxarifado::where('solicitacao_id', $id)->get();

        $itens = $itens->map(function ($item) {
            $descricao = MaterialModel::find($item->material_id)->descricao;

            return [
                'material' => [
                    'id' => $item->material_id,
                    'descricao_completa' => $descricao,
                    'quantidade' => $item->quantidade,
                ],
                'quantidade' => $item->quantidade,
            ];
        });

        return $itens ?? [];
    }

    private static function getCausaProvavel($solicitacaoId)
    {
        $causasProvaveisIds = SolicitacaoCausaProvavel::where('solicitacao_id', $solicitacaoId)->get();

        $causasProvaveis = [];

        foreach ($causasProvaveisIds as $causaProvavel) {
            $causasProvaveis[] = ServicoManutencaoCausasProvaveis::find($causaProvavel->causa_provavel_id);
        }

        return $causasProvaveis;
    }

    private static function getPrestadores($servicoId)
    {
        $unidadeExecutanteManutencao = ServicoManutencaoPrestadorFornecedor::where('servico_manutencao_id', $servicoId)
            ->join('cadastro_unidade_executante_manutencao', 'cadastro_unidade_executante_manutencao.id', '=', 'cadastro_servico_manutencao_prestador_fornecedor.unidade_executante_manutencao_id')
            ->select('cadastro_servico_manutencao_prestador_fornecedor.id as prestador_id', 'cadastro_unidade_executante_manutencao.*')
            ->get();

        foreach ($unidadeExecutanteManutencao as $unidade) {
            if ($unidade->is_prestador) {
                $prestadoresFornecedores[] = (object) [
                    'id' => $unidade->prestador_id,
                    'nome_unidade' => $unidade->getFornecedor->nome_fantasia ?? null,
                ];
            } else {
                if (!is_null($unidade->usuario_id)) {
                    $unidadeModel = UnidadeExecutanteManutencao::where('id', $unidade->id)->first();
                    $usuario = $unidadeModel->getUsuario;
                    $nomeUsuario = ' - ' . $usuario->nome;
                } else {
                    $nomeUsuario = null;
                }

                if (is_null($unidade->getInfraestrutura) || is_null($unidade->getInfraestrutura->unidade)) {
                    $sql = DB::table('cadastro_infraestrutura')
                        ->join('cadastro_unidade', 'cadastro_infraestrutura.unidade_id', '=', 'cadastro_unidade.id')
                        ->where('cadastro_infraestrutura.id', $unidade->infraestrutura_id)
                        ->select('cadastro_unidade.nome_fantasia', 'cadastro_infraestrutura.id')
                        ->first();

                    $nome = $sql->nome_fantasia . $nomeUsuario;
                }

                $nomeUnidade = $unidade->getInfraestrutura->unidade->nome_fantasia ?? null;

                if ($nomeUnidade) {
                    $nome = $nomeUnidade . $nomeUsuario;
                }

                $prestadoresFornecedores[] = (object) [
                    'id' => $unidade->prestador_id,
                    'nome_unidade' => $nome,
                ];
            }
        }

        $prestadoresFornecedores = $prestadoresFornecedores ?? [];

        usort($prestadoresFornecedores, function ($a, $b) {
            return $a->nome_unidade <=> $b->nome_unidade;
        });
        
        return $prestadoresFornecedores;
    }

    private static function getMensage($solicitacao)
    {
        $mensagens = SolicitacaoMensagem::where('solicitacao_id', $solicitacao->id)
            ->orderBy('id', 'desc')
            ->get();

        $mensagens->each(function ($mensagem) {
            $mensagem->is_respondida = $mensagem->is_respondida ? 'Sim' : 'Não';
        });

        $resposta = SolicitacaoResposta::where('solicitacao_id', $solicitacao->id)
            ->orderBy('id', 'desc')
            ->get();

        $mensagens = $mensagens->map(function ($mensagem, $key) use ($resposta) {
            return [
                'resposta' => isset($resposta[$key]) ? [
                    'mensagem' => $resposta[$key]->mensagem ?? null,
                    'data' => $resposta[$key]->created_at->format('d/m/Y') ?? null,
                    'hora' => $resposta[$key]->created_at->format('H:i') ?? null,
                    'nome_usuario' => $resposta[$key]->usuario->cidadao->nome ?? null,
                    'nome_unidade' => $resposta[$key]->infraestrutura->unidade->nome_fantasia ?? null,
                ] : null,
                'mensagem' => [
                    'mensagem' => $mensagem->mensagem,
                    'data' => $mensagem->created_at->format('d/m/Y'),
                    'hora' => $mensagem->created_at->format('H:i'),
                    'is_respondida' => $mensagem->is_respondida ?? FALSE,
                    'resposta' => $mensagem->is_respondida,
                    'nome_usuario' => $mensagem->usuario->cidadao->nome,
                    'nome_unidade' => $mensagem->infraestrutura->unidade->nome_fantasia,
                ],
            ];
        });

        return $mensagens;
    }

    public static function update($id)
    {
        $solicitacao = Solicitacao::findOrFail($id);

        if (request()->filled('acao')) {

            switch (request('acao')) {
                case 'finalizar':

                    return self::finalizar($solicitacao);
                case 'mensagem':

                    return self::mensagem($solicitacao);
                default:

                    return self::updateSolicitacao($solicitacao);
            }
        } else {

            return self::updateSolicitacao($solicitacao);
        }
    }

    private static function finalizar($solicitacao)
    {
        $solicitacao->fill([
            'pendente_finalizacao' => true,
            'usuario_finalizador_id' => self::getCurrentLotacao()->usuario->id,
            'infraestrutura_finalizacao_id' => self::getCurrentLotacao()->infraestrutura->id,
        ]);

        $solicitacao->save();
        return $solicitacao;
    }

    private static function mensagem($solicitacao)
    {
        $mensagem = new GerenciamentoMensagem();

        $mensagem->fill([
            'solicitacao_id' => $solicitacao->id,
            'infraestrutura_id' => self::getCurrentCentroCusto()->infraestrutura->id,
            'usuario_id' => self::getCurrentLotacao()->usuario->id,
            'mensagem' => request('comentario_atual'),
        ]);

        $mensagem->save();

        return $solicitacao;
    }

    private static function updateSolicitacao($solicitacao)
    {
        $status = Status::where('id', $solicitacao->status_id)->firstOrFail();
        if ($status->tipo_id === StatusEnum::CANCELADO || $status->tipo_id === StatusEnum::FINALIZADO) return $solicitacao;

        self::updateValidate();
        $data = request()->all();

        if (isset($data['custo']) && $data['custo']) {
            $data['custo'] = str_replace('.', '', $data['custo']);
            $data['custo'] = str_replace(',', '.', $data['custo']);
        }

        $solicitacao->fill([
            'prestador_id' => $data['prestador_id'],
            'custo' => $data['custo'] ?? null,
            'data_agendamento' => $data['data_agendamento_formatada'] ? Carbon::createFromFormat('d/m/Y', $data['data_agendamento_formatada'])->format('Y-m-d') : null,
            'os_prestador' => $data['os_prestador'],
            'usuario_atendente_id' => self::getCurrentLotacao()->usuario->id,
            'infraestrutura_atendente_id' => self::getCurrentLotacao()->infraestrutura->id,
        ]);

        $solicitacao->status_id = StatusEnum::EM_ATENDIMENTO;
        $solicitacao->save();

        $solicitacao->refresh();

        if ($data['comentario_atual']) {

            $mensagem = new SolicitacaoMensagem();

            $mensagem->fill([
                'solicitacao_id' => $solicitacao->id,
                'infraestrutura_id' => self::getCurrentCentroCusto()->infraestrutura->id,
                'usuario_id' => self::getCurrentLotacao()->usuario->id,
                'mensagem' => $data['comentario_atual'],
            ]);

            $mensagem->save();
        }

        if (isset($data['itens']) && $data['itens']) {
            $solicitacao->itensAlmoxarifado()->delete();

            foreach($data['itens'] as $item) {
                $itens = new SolicitacaoItensAlmoxarifado();

                $itens->fill([
                    'solicitacao_id' => $solicitacao->id,
                    'material_id' => $item['material']['id'],
                    'quantidade' => $item['quantidade'],
                ]);

                $itens->save();
            }
        }

        $historico = new SolicitacaoStatusHistorico();

        $historico->fill([
            'solicitacao_id' => $solicitacao->id,
            'status_id' => $solicitacao->status_id,
            'origem_id' => StatusEnum::EM_ATENDIMENTO,
            'usuario_id' => self::getCurrentLotacao()->usuario->id,
            'infraestrutura_id' => self::getCurrentLotacao()->infraestrutura->id,
            'mensagem' => $data['comentario_atual'] ?? null,
            'prestador_id' => $data['prestador_id'],
            'custo' => $data['custo'] ?? null,
            'data_agendamento' => $data['data_agendamento_formatada'] ? Carbon::createFromFormat('d/m/Y', $data['data_agendamento_formatada'])->format('Y-m-d') : null,
            'os_prestador' => $data['os_prestador'],
            'usuario_atendente_id' => self::getCurrentLotacao()->usuario->id,
            'infraestrutura_atendente_id' => self::getCurrentLotacao()->infraestrutura->id,
        ]);

        $historico->save();

        return $solicitacao;
    }

    private static function updateValidate()
    {
        $rule = [
            'comentario_atual' => [
                'nullable',
                'string',
                'max:500',
            ],
            'prestador_id' => [
                'required',
                'integer',
                Rule::exists('cadastro_servico_manutencao_prestador_fornecedor', 'id'),
            ],
            'data_agendamento_formatada' => [
                'nullable',
                'date_format:d/m/Y',
            ],
            'os_prestador' => [
                'nullable',
                'string',
                'max:10'
            ],
            'custo' => [
                'nullable',
                'string',
            ],
        ];

        request()->validate($rule);
    }
}