<?php

namespace App\Services\Cadastro;

use App\Enums\Cadastro\Grupo\GrupoTipo as GrupoEnum;
use App\Models\Cadastro\Grupo\Grupo;
use App\Models\Cadastro\ServicoManutencao;
use App\Models\Cadastro\ServicoManutencaoCausasProvaveis;
use App\Models\Cadastro\ServicoManutencaoPrestadorFornecedor;
use App\Models\Cadastro\Subgrupo\Subgrupo;
use App\Models\Cadastro\UnidadeExecutanteManutencao;
use App\Models\Manutencao\Prioridade;
use App\Models\Manutencao\SolicitacaoCausaProvavel;
use App\Services\Service;
use DB;
use Illuminate\Validation\Rule;

class ServicoManutencaoService extends Service
{
    public static function datatable()
    {

        $servicos = DB::table('cadastro_servico_manutencao as servico_manutencao')
            ->leftJoin('cadastro_grupo as grupo', 'grupo.id', 'servico_manutencao.grupo_id')
            ->leftJoin('cadastro_subgrupo as sub_grupo', 'sub_grupo.id', 'servico_manutencao.sub_grupo_id')
            ->leftJoin('manutencao_parametrizacao_prioridade as prioridade', 'prioridade.id', 'servico_manutencao.prioridade_id')
            ->select(
                'servico_manutencao.id',
                'servico_manutencao.nome',
                'grupo.nome as grupo_nome',
                DB::raw('COALESCE(sub_grupo.nome, "NÃO INFORMADO") as sub_grupo_nome'),
                DB::raw('COALESCE(prioridade.nome, "NÃO INFORMADA") as prioridade_nome'),
                DB::raw('
                    CASE
                        WHEN EXISTS (
                            SELECT 1
                            FROM manutencao_solicitacao
                            WHERE manutencao_solicitacao.servico_id = servico_manutencao.id
                        ) THEN TRUE
                        ELSE FALSE
                    END as allow_destroy
                ')
            )
            ->orderBy('servico_manutencao.nome')
            ->get();

        return $servicos;
    }

    public static function create()
    {

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

    private static function getModelData()
    {

        return [
            'causa_provavel' => null,
            'causas_provaveis' => [],
            'grupo_id' => null,
            'is_agendamento_programado' => false,
            'is_custo' => false,
            'is_identifica_os_prestador' => false,
            'is_identifica_itens_almoxarifado' => false,
            'nome' => null,
            'prestador_fornecedor_id' => null,
            'prestadores_fornecedores' => [],
            'prioridade_id' => null,
            'sub_grupo_id' => null,
        ];
    }

    private static function getFormData()
    {

        return [
            'grupos' => Grupo::where('grupo_tipo_id', GrupoEnum::MANUTENCAO)
                ->get(),
            'sub_grupos' => [],
            'prioridades' => Prioridade::all(),
            'prestadores_fornecedores' => self::getPrestadoresFornecedores(),
        ];
    }

    public static function list()
    {

        $params = request()->only('params');

        switch (request()->listar) {

            case 'subGrupo':

               return self::getSubgrupos($params);
            default:

                $data = [];
                break;
        }
    }

    private static function getSubgrupos($params)
    {

        return Subgrupo::where('grupo_id', $params)
            ->get();
    }

    private static function getPrestadoresFornecedores()
    {

        $unidadeExecutanteManutencao = UnidadeExecutanteManutencao::all();

        foreach ($unidadeExecutanteManutencao as $unidade) {

            if ($unidade->is_prestador) {

                $prestadoresFornecedores[] = (object) [
                    'id_registro' => $unidade->id,
                    'id_prestador' => $unidade->id ?? null,
                    'nome_fantasia' => $unidade->getFornecedor->nome_fantasia ?? null,
                ];
            } else {

                if (!is_null($unidade->usuario_id)) {

                    $usuario = $unidade->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;
                    $id = $sql->id;
                }

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

                if ($nomeUnidade) {

                    $nome = $nomeUnidade . $nomeUsuario;
                }

                $prestadoresFornecedores[] = (object) [
                    'id_registro' => $unidade->id,
                    'id_prestador' => $unidade->getInfraestrutura->id ?? $id ?? null,
                    'nome_fantasia' => $nome ?? null,
                ];
            }
        };

        $prestadoresFornecedores = $prestadoresFornecedores ?? [];

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

        return $prestadoresFornecedores;
    }

    public static function store()
    {

        self::validate();

        $servicoManutencao = new ServicoManutencao();

        DB::transaction(function () use ($servicoManutencao) {

            $servicoManutencao->fill([
                'nome' => request('nome'),
                'grupo_id' => request('grupo_id'),
                'sub_grupo_id' => request('sub_grupo_id'),
                'prioridade_id' => request('prioridade_id'),
                'is_agendamento_programado' => request('is_agendamento_programado'),
                'is_custo' => request('is_custo'),
                'is_identifica_os_prestador' => request('is_identifica_os_prestador'),
                'is_identifica_itens_almoxarifado' => request('is_identifica_itens_almoxarifado'),
            ]);

            $servicoManutencao->save();

            collect(request()->prestadores_fornecedores)->each(function ($prestadorFornecedor) use ($servicoManutencao) {

                $servicoManutencao->prestadoresFornecedores()->create([
                    'servico_manutencao_id' => $servicoManutencao->id,
                    'unidade_executante_manutencao_id' => $prestadorFornecedor['id_registro'],
                ]);
            });

            collect(request()->causas_provaveis)->each(function ($causaProvavel) use ($servicoManutencao) {

                $servicoManutencao->causasProvaveis()->create([
                    'nome' => $causaProvavel['nome_causa'],
                    'servico_manutencao_id' => $servicoManutencao->id,
                    'observacao' => $causaProvavel['observacao'] ?? null,
                ]);
            });
        });

        return $servicoManutencao->refresh();
    }

    public static function edit($id)
    {

        $servicoManutencao = ServicoManutencao::findOrFail($id);
        $idSolicitacao = $id;

        $prestadoresFornecedores = ServicoManutencaoPrestadorFornecedor::where('servico_manutencao_id', $id)
            ->get();

        foreach ($prestadoresFornecedores as $prestadorFornecedor) {

            $cadastroPrestadorFornecedor = UnidadeExecutanteManutencao::findOrFail($prestadorFornecedor->unidade_executante_manutencao_id);

            if (is_null($cadastroPrestadorFornecedor->getInfraestrutura) || is_null($cadastroPrestadorFornecedor->getInfraestrutura->unidade)) {

                $sql = DB::table('cadastro_infraestrutura')
                    ->join('cadastro_unidade', 'cadastro_infraestrutura.unidade_id', 'cadastro_unidade.id')
                    ->join('cadastro_unidade_executante_manutencao', 'cadastro_unidade_executante_manutencao.infraestrutura_id', 'cadastro_infraestrutura.id')
                    ->join('cadastro_servico_manutencao_prestador_fornecedor', 'cadastro_servico_manutencao_prestador_fornecedor.unidade_executante_manutencao_id', 'cadastro_unidade_executante_manutencao.id')
                    ->where('cadastro_servico_manutencao_prestador_fornecedor.id', $prestadorFornecedor->id)
                    ->select('cadastro_unidade.nome_fantasia', 'cadastro_infraestrutura.id')
                    ->first();

                $nome = $sql->nome_fantasia ?? null;
                $id = $sql->id ?? null;
            }

            if ($cadastroPrestadorFornecedor->is_prestador) {

                $prestadoresFornecedoresData[] = (object) [
                    'id' => $prestadorFornecedor->id,
                    'id_registro' => $cadastroPrestadorFornecedor->id,
                    'id_prestador' => $cadastroPrestadorFornecedor->id ?? null,
                    'nome_fantasia' => $cadastroPrestadorFornecedor->getFornecedor->nome_fantasia ?? null,
                    'allow_destroy' => TRUE,
                ];
            } else {

                $prestadoresFornecedoresData[] = (object) [
                    'id' => $prestadorFornecedor->id,
                    'id_registro' => $cadastroPrestadorFornecedor->id,
                    'id_prestador' => $cadastroPrestadorFornecedor->getInfraestrutura->id ?? null,
                    'nome_fantasia' => $cadastroPrestadorFornecedor->getInfraestrutura->unidade->nome_fantasia ?? $nome ?? null,
                    'allow_destroy' => TRUE,
                ];
            }
        }

        $causasProvaveis = ServicoManutencaoCausasProvaveis::where('servico_manutencao_id', $idSolicitacao)
            ->get();

        foreach ($causasProvaveis as $causaProvavel) {

            $causasProvaveisData[] = (object) [
                'id' => $causaProvavel->id,
                'nome_causa' => $causaProvavel->nome,
                'observacao' => $causaProvavel->observacao,
                'allow_destroy' => SolicitacaoCausaProvavel::where('causa_provavel_id', $causaProvavel->id)
                    ->exists(),
            ];
        }

        $data = [
            'causa_provavel' => null,
            'grupo_id' => $servicoManutencao->grupo_id,
            'is_agendamento_programado' => $servicoManutencao->is_agendamento_programado,
            'is_custo' => $servicoManutencao->is_custo,
            'is_identifica_os_prestador' => $servicoManutencao->is_identifica_os_prestador,
            'is_identifica_itens_almoxarifado' => $servicoManutencao->is_identifica_itens_almoxarifado,
            'nome' => $servicoManutencao->nome,
            'prestador_fornecedor_id' => null,
            'prioridade_id' => $servicoManutencao->prioridade_id,
            'sub_grupo_id' => $servicoManutencao->sub_grupo_id,
            'prestadores_fornecedores' => $prestadoresFornecedoresData ?? [],
            'causas_provaveis' => $causasProvaveisData ?? [],
        ];

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

    public static function update($id)
    {

        $servicoManutencao = ServicoManutencao::findOrFail($id);

        self::validate();

        DB::transaction(function () use ($servicoManutencao, $id) {

            $servicoManutencao->fill([
                'nome' => request('nome'),
                'grupo_id' => request('grupo_id'),
                'sub_grupo_id' => request('sub_grupo_id'),
                'prioridade_id' => request('prioridade_id'),
                'is_agendamento_programado' => request('is_agendamento_programado'),
                'is_custo' => request('is_custo'),
                'is_identifica_os_prestador' => request('is_identifica_os_prestador'),
                'is_identifica_itens_almoxarifado' => request('is_identifica_itens_almoxarifado'),
            ]);

            $servicoManutencao->save();

            ServicoManutencaoPrestadorFornecedor::where('servico_manutencao_id', $id)
                ->whereNotIn('id', collect(request()->prestadores_fornecedores)->pluck('id'))
                ->delete();

            collect(request()->prestadores_fornecedores)->each(function ($prestadorFornecedor) use ($servicoManutencao) {

                if (!isset($prestadorFornecedor['id'])) {

                    $servicoManutencao->prestadoresFornecedores()->create([
                        'servico_manutencao_id' => $servicoManutencao->id,
                        'unidade_executante_manutencao_id' => $prestadorFornecedor['id_registro'],
                    ]);
                }
            });

            $causasProvaveis = ServicoManutencaoCausasProvaveis::where('servico_manutencao_id', $id)
                ->get();

            ServicoManutencaoCausasProvaveis::where('servico_manutencao_id', $id)
                ->whereNotIn('id', collect(request()->causas_provaveis)->pluck('id'))
                ->delete();

            collect(request()->causas_provaveis)->each(function ($causaProvavel) use ($servicoManutencao, $causasProvaveis) {

                if (!isset($causaProvavel['id'])) {

                    $servicoManutencao->causasProvaveis()->create([

                        'nome' => $causaProvavel['nome_causa'],
                        'observacao' => $causaProvavel['observacao'] ?? null,
                    ]);
                } else {

                    $causaProvavelExistente = $causasProvaveis->where('id', $causaProvavel['id'])->first();

                    $causaProvavelExistente->fill([

                        'nome' => $causaProvavel['nome_causa'],
                        'observacao' => $causaProvavel['observacao'] ?? null,
                    ]);

                    $causaProvavelExistente->save();
                }
            });
        });
    }

    public static function validate()
    {

        $rule = [
            'nome' => [
                'required',
                'max:100',
                'min:3',
                Rule::unique('cadastro_servico_manutencao', 'nome')
                    ->ignore(request()->route('servico_manutencao')),
            ],
            'grupo_id' => [
                'required',
                'integer',
                Rule::exists('cadastro_grupo', 'id'),
            ],
            'sub_grupo_id' => [
                'nullable',
                'integer',
                Rule::exists('cadastro_subgrupo', 'id'),
            ],
            'prioridade_id' => [
                'nullable',
                'integer',
                Rule::exists('manutencao_parametrizacao_prioridade', 'id'),
            ],
            'is_agendamento_programado' => [
                'nullable',
                'boolean',
            ],
            'is_custo' => [
                'nullable',
                'boolean',
            ],
            'is_identifica_os_prestador' => [
                'nullable',
                'boolean',
            ],
            'prestadores_fornecedores' => [
                'present',
                'array',
            ],
            'prestadores_fornecedores.*.id_registro' => [
                'required',
                'integer',
                Rule::exists('cadastro_unidade_executante_manutencao', 'id'),
            ],
            'causas_provaveis' => [
                'present',
                'array',
            ],
            'causas_provaveis.*.nome_causa' => [
                'required',
                'string',
                'max:100',
                'min:3',
            ],
            'causa_provavel.*.observacao' => [
                'nullable',
                'string',
                'max:1000',
            ],
        ];


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

    public static function destroy($id)
    {
        ServicoManutencao::findOrFail($id)->delete();

        return null;
    }
}