<?php

namespace App\Services\Almoxarifado\Relatorios;

use App\Enums\Almoxarifado\RequisicaoRespostaItemMotivo;
use App\Enums\Almoxarifado\RequisicaoRespostaStatus;
use App\Enums\Almoxarifado\RequisicaoStatus;
use App\Models\Almoxarifado\Requisicao;
use App\Models\Almoxarifado\RequisicaoItem;
use App\Models\Almoxarifado\RequisicaoResposta;
use App\Models\Cadastro\Estabelecimento\CentroCusto;
use App\Models\Cadastro\Estabelecimento\Infraestrutura;
use App\Models\Cadastro\Estabelecimento\Unidade;
use App\Models\Cadastro\Grupo\Grupo;
use App\Models\Cadastro\Material\Material;
use App\Models\Cadastro\Subgrupo\Subgrupo;
use App\Models\Cadastro\SujeitoAtencao\Usuario;
use App\Services\Cadastro\Material\MaterialService;
use App\Services\Service;
use App\Utils\DataUtil;
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;

class RequisicaoService extends Service
{
    public static function index()
    {
        $periodo = is_null(request()->periodo) ? null : [
            'start' => Carbon::createFromFormat('d/m/Y', request()->periodo['start'])->setTime(0, 0, 0),
            'end' => Carbon::createFromFormat('d/m/Y', request()->periodo['end'])->setTime(23, 59, 59)
        ];

        $requisicoesBuilder = DB::table('almoxarifado_requisicao as requisicao')
            ->join(
                'cadastro_centro_custo as centro_custo_almoxarifado',
                'centro_custo_almoxarifado.id',
                'requisicao.centro_custo_id'
            )
            ->join(
                'cadastro_infraestrutura as infraestrutura_almoxarifado',
                'infraestrutura_almoxarifado.id',
                'centro_custo_almoxarifado.infraestrutura_id'
            )
            ->join(
                'cadastro_centro_custo as centro_custo_requisitante',
                'centro_custo_requisitante.id',
                'requisicao.created_centro_custo_id'
            )
            ->join(
                'cadastro_setor as setor_requisitante',
                'setor_requisitante.id',
                'centro_custo_requisitante.setor_id'
            )
            ->join(
                'cadastro_infraestrutura as infraestrutura_requisitante',
                'infraestrutura_requisitante.id',
                'centro_custo_requisitante.infraestrutura_id'
            )
            ->join(
                'cadastro_unidade as unidade_requisitante',
                'unidade_requisitante.id',
                'infraestrutura_requisitante.unidade_id'
            )
            ->join(
                'cadastro_lotacao as lotacao_requisitante',
                'lotacao_requisitante.id',
                'requisicao.created_lotacao_id'
            )
            ->join(
                'cadastro_usuario as usuario_requisitante',
                'usuario_requisitante.id',
                'lotacao_requisitante.usuario_id'
            )
            ->join(
                'cadastro_cidadao as cidadao_requisitante',
                'cidadao_requisitante.id',
                'usuario_requisitante.cidadao_id'
            )
            ->when(request()->requisicao_id,
                fn ($q, $id) => $q->where('requisicao.id', $id),
                fn ($q) => $q
                    ->whereBetween('requisicao.created_at', $periodo)
                    ->when(request()->requisicao_id, fn ($q, $id) => $q)
                    ->when(request()->unidade_id, fn ($q, $id) => $q->where('infraestrutura_almoxarifado.unidade_id', $id))
                    ->when(request()->infraestrutura_id, fn ($q, $id) => $q->where('infraestrutura_almoxarifado.id', $id))
                    ->when(request()->centro_custo_id, fn ($q, $id) => $q->where('centro_custo_almoxarifado.id', $id))
                    ->when(request()->unidade_requisitante_id, fn ($q, $id) => $q->where('infraestrutura_requisitante.unidade_id', $id))
                    ->when(request()->infraestrutura_requisitante_id, fn ($q, $id) => $q->where('infraestrutura_requisitante.id', $id))
                    ->when(request()->centro_custo_requisitante_id, fn ($q, $id) => $q->where('centro_custo_requisitante.id', $id))
                    ->when(request()->usuario_requisitante_id, fn ($q, $id) => $q->where('usuario_requisitante.id', $id))
                    ->when(request()->status, function ($query, $status) {

                        $getWhereResposta = function ($statusId, $parcial = false) {

                            return self::getSqlStatus($statusId, $parcial, 'requisicao');
                        };

                        if ($status == 'aberta') {

                            $query->where('requisicao.status_id', RequisicaoStatus::ABERTA);
                        }
                        else if ($status == 'finalizada') {

                            $query->where('requisicao.status_id', RequisicaoStatus::FINALIZADA);
                        }
                        else {

                            $query->where('requisicao.status_id', RequisicaoStatus::RESPOSTA_INICIADA);

                            if ($status == 'em_andamento') {

                                $query->whereRaw($getWhereResposta(RequisicaoRespostaStatus::INICIADA));
                            }
                            else if ($status == 'enviado') {

                                $query->whereRaw($getWhereResposta(RequisicaoRespostaStatus::ENVIADA));
                            }
                            else if ($status == 'enviado_parcial') {

                                $query->whereRaw($getWhereResposta(RequisicaoRespostaStatus::ENVIADA, true));
                            }
                            else if ($status == 'finalizada_parcial') {

                                $query->whereRaw($getWhereResposta(RequisicaoRespostaStatus::RECEBIDA, true));
                            }
                        }
                    })
                    ->when(request()->numero, fn ($q, $numero) => $q->where('requisicao.numero', $numero))
                    ->whereExists(function ($query) {

                        $query->select(DB::raw(1))
                            ->from('almoxarifado_requisicao_item as item')
                            ->join('cadastro_material as material', 'material.id', 'item.material_id')
                            ->whereColumn('item.requisicao_id', 'requisicao.id')
                            ->when(request()->grupo_id, fn ($q, $id) => $q->where('material.grupo_id', $id))
                            ->when(request()->subgrupo_id, fn ($q, $id) => $q->where('material.subgrupo_id', $id))
                            ->when(request()->material_id, fn ($q, $id) => $q->where('material.id', $id));
                    })
            )
            ->select(DB::raw("
                requisicao.id,
                CAST(requisicao.created_at as DATE) as data,
                requisicao.numero,
                unidade_requisitante.nome_fantasia as unidade_requisitante,
                COALESCE(infraestrutura_requisitante.nome, unidade_requisitante.nome_fantasia) as infraestrutura_requisitante,
                setor_requisitante.nome as setor_requisitante,
                cidadao_requisitante.nome as usuario_requisitante,
                (
                    CASE requisicao.status_id
                        WHEN " . RequisicaoStatus::ABERTA . " THEN 'ABERTA'
                        WHEN " . RequisicaoStatus::FINALIZADA . " THEN 'FINALIZADA'
                        WHEN " . RequisicaoStatus::RESPOSTA_INICIADA . " THEN (
                            CASE
                                WHEN (" . self::getSqlStatus(RequisicaoRespostaStatus::INICIADA, false, 'requisicao') . ")
                                    THEN 'EM ANDAMENTO'
                                WHEN (" . self::getSqlStatus(RequisicaoRespostaStatus::ENVIADA, false, 'requisicao') . ")
                                    THEN 'ENVIADO'
                                WHEN (" . self::getSqlStatus(RequisicaoRespostaStatus::ENVIADA, true, 'requisicao') . ")
                                    THEN 'ENVIADO PARCIAL'
                                WHEN (" . self::getSqlStatus(RequisicaoRespostaStatus::RECEBIDA, true, 'requisicao') . ")
                                    THEN 'FINALIZADA PARCIAL'
                            END
                        )
                    END
                ) as status
            "));

        self::setOrderBy($requisicoesBuilder);

        $requisicoes = $requisicoesBuilder->get();

        if (DataUtil::getBooleanValueFromStringBoolean(request()->with_details)) {

            $requisicoes->each(function ($requisicao) {

                $requisicao->respostas = self::getRespostas($requisicao->id);

                $requisicao->itens = $requisicao->respostas->isNotEmpty()
                    ? collect()
                    : RequisicaoItem::where('requisicao_id', $requisicao->id)
                        ->whereHas('material', fn ($q) => $q
                            ->when(request()->grupo_id, fn ($q, $id) => $q->where('grupo_id', $id))
                            ->when(request()->subgrupo_id, fn ($q, $id) => $q->where('subgrupo_id', $id))
                            ->when(request()->material_id, fn ($q, $id) => $q->where('id', $id))
                        )
                        ->get(['material_id', 'quantidade'])
                        ->map(fn ($item) => (object) [
                            'material' => $item->material->descricao_completa,
                            'requisitado' => $item->quantidade,
                            'enviado' => null,
                            'recebido' => null,
                            'lote' => null,
                            'validade_lote' => null,
                            'motivo_diferenca' => null,
                        ])
                        ->sortBy('material')
                        ->values();
            });
        }

        return compact('requisicoes');
    }

    private static function setOrderBy($builder)
    {
        if (is_null(request()->sortBy)) {

            $builder->orderBy('requisicao.id');

            return;
        }

        $columns = [
            'data' => 'requisicao.created_at',
            'numero' => 'requisicao.numero',
            'unidade_requisitante' => 'unidade_requisitante.nome_fantasia',
            'infraestrutura_requisitante' => 'COALESCE(
                infraestrutura_requisitante.nome,
                unidade_requisitante.nome_fantasia
            )',
            'setor_requisitante' => 'setor_requisitante.nome',
            'usuario_requisitante' => 'cidadao_requisitante.nome',
            'status' => "(
                CASE requisicao.status_id
                    WHEN " . RequisicaoStatus::ABERTA . " THEN 'ABERTA'
                    WHEN " . RequisicaoStatus::FINALIZADA . " THEN 'FINALIZADA'
                    WHEN " . RequisicaoStatus::RESPOSTA_INICIADA . " THEN (
                        CASE
                            WHEN (" . self::getSqlStatus(RequisicaoRespostaStatus::INICIADA, false, 'requisicao') . ")
                                THEN 'EM ANDAMENTO'
                            WHEN (" . self::getSqlStatus(RequisicaoRespostaStatus::ENVIADA, false, 'requisicao') . ")
                                THEN 'ENVIADO'
                            WHEN (" . self::getSqlStatus(RequisicaoRespostaStatus::ENVIADA, true, 'requisicao') . ")
                                THEN 'ENVIADO PARCIAL'
                            WHEN (" . self::getSqlStatus(RequisicaoRespostaStatus::RECEBIDA, true, 'requisicao') . ")
                                THEN 'FINALIZADA PARCIAL'
                        END
                    )
                END
            )",
        ];

        $column = $columns[request()->sortBy];
        $direction = DataUtil::getBooleanValueFromStringBoolean(request()->sortDesc) ? 'DESC' : 'ASC';

        $builder->orderByRaw("{$column} {$direction}, requisicao.id");
    }

    private static function getRespostas($requisicaoId)
    {
        $recebido = [];

        return RequisicaoResposta::where('requisicao_id', $requisicaoId)
            ->where(fn ($q) => $q
                ->where('status_id', RequisicaoRespostaStatus::RECEBIDA)
                ->orWhere(fn ($q) => $q
                    ->where('status_id', RequisicaoRespostaStatus::ENVIADA)
                    ->where('id', RequisicaoResposta::where('requisicao_id', $requisicaoId)
                        ->where('status_id', RequisicaoRespostaStatus::ENVIADA)
                        ->orderBy('id')
                        ->first(['id'])->id ?? null
                    )
                )
            )
            ->orderBy('id')
            ->get(['id', 'status_id', 'enviada_em', 'recebida_em', 'enviada_lotacao_id', 'observacoes'])
            ->map(function ($resposta, $i) use (&$recebido) {

                $numeroResposta = $i + 1;

                $itens = $resposta->itens()
                    ->whereHas('requisicaoItem', fn ($q) => $q
                        ->whereHas('material', fn ($q) => $q
                            ->when(request()->grupo_id, fn ($q, $id) => $q->where('grupo_id', $id))
                            ->when(request()->subgrupo_id, fn ($q, $id) => $q->where('subgrupo_id', $id))
                            ->when(request()->material_id, fn ($q, $id) => $q->where('id', $id))
                        )
                    )
                    ->get(['id', 'requisicao_item_id', 'saida_item_id', 'motivo_id', 'motivo_outro'])
                    ->map(function ($respostaItem) use ($numeroResposta, &$recebido) {

                        $requisicaoItem = $respostaItem->requisicaoItem()
                            ->first(['material_id', 'quantidade']);

                        $saidaItem = $respostaItem->saidaItem()->first(['id']);

                        if (!isset($recebido[$requisicaoItem->material_id])) {

                            $recebido[$requisicaoItem->material_id] = 0;
                        }

                        $item = (object) [
                            'material' => $requisicaoItem->material->descricao_completa,
                            'requisitado' => $numeroResposta === 1
                                ? $requisicaoItem->quantidade
                                : $requisicaoItem->quantidade - $recebido[$requisicaoItem->material_id],
                            'possui_entrada_com_lote' => is_null($saidaItem)
                                ? false
                                : $saidaItem->entradaItens()->whereNotNull('lote')->exists(),
                            'motivo_diferenca' => is_null($respostaItem->motivo_id)
                                ? null
                                : $respostaItem->motivo()->first(['nome'])->nome . (
                                    $respostaItem->motivo_id ==  RequisicaoRespostaItemMotivo::OUTRO
                                        ? " ({$respostaItem->motivo_outro})"
                                        : ''),
                        ];

                        if ($item->possui_entrada_com_lote) {

                            $item->entrada_itens = $saidaItem->entradaItens()
                                ->get(['id', 'lote', 'validade_lote'])
                                ->map(function ($entradaItem) use ($respostaItem) {

                                    $recebimento = $respostaItem->recebimentos()
                                        ->where('entrada_item_origem_id', $entradaItem->id)
                                        ->first(['quantidade', 'lote', 'validade_lote']);

                                    $data = (object) [
                                        'enviado' => $entradaItem->pivotSaidaItemEntradaItem->quantidade_saida,
                                        'recebido' => 0,
                                    ];

                                    if (is_null($recebimento)) {

                                        $data->lote = $entradaItem->lote;

                                        $data->validade_lote = is_null($entradaItem->validade_lote)
                                            ? null
                                            : $entradaItem->validade_lote->format('d/m/Y');
                                    }
                                    else {

                                        $loteDiferente = $recebimento->lote !== $entradaItem->lote;

                                        $validadeLoteDiferente = !is_null($recebimento->validade_lote)
                                            && !is_null($entradaItem->validade_lote)
                                                ? $recebimento->validade_lote->format('d/m/Y')
                                                    !== $entradaItem->validade_lote->format('d/m/Y')
                                                : false;

                                        $data->recebido = $recebimento->quantidade;

                                        $data->lote = $loteDiferente
                                            ? "{$entradaItem->lote} (Enviado) | {$recebimento->lote} (Recebido)"
                                            : $recebimento->lote;

                                        $data->validade_lote = is_null($entradaItem->validade_lote)
                                            ? null
                                            : ($validadeLoteDiferente
                                                ? "{$entradaItem->validade_lote->format('d/m/Y')} (Enviado) | "
                                                    . "{$recebimento->validade_lote->format('d/m/Y')} (Recebido)"
                                                : $recebimento->validade_lote->format('d/m/Y'));
                                    }

                                    return $data;
                                });

                            $recebido[$requisicaoItem->material_id] += $item->entrada_itens->sum('recebido');
                        }
                        else {

                            $item->enviado = $saidaItem->quantidade ?? 0;
                            $item->recebido = $respostaItem->quantidade_recebimento ?? 0;

                            $recebido[$requisicaoItem->material_id] += $item->recebido;
                        }

                        return $item;
                    });

                return (object) [
                    'numero_resposta' => $numeroResposta,
                    'data_hora_recebimento' => is_null($resposta->recebida_em)
                        ? null : $resposta->recebida_em->format('d/m/Y H:i'),
                    'data_hora_envio' => is_null($resposta->enviada_em)
                        ? null : $resposta->enviada_em->format('d/m/Y H:i'),
                    'usuario_envio' => is_null($resposta->enviada_lotacao_id)
                        ? null
                        : $resposta->enviadaLotacao()->setEagerLoads([])->first(['usuario_id'])
                            ->usuario()->setEagerLoads([])->first(['cidadao_id'])
                            ->cidadao()->setEagerLoads([])->first(['nome'])->nome,
                    'itens' => $itens->sortBy('material')->values(),
                    'observacoes' => $resposta->observacoes,
                ];
            });
    }

    public static function list()
    {
        $data = (object) [
            'additionals' => [],
            'form' => [],
            'model' => [],
        ];

        $params = self::getParams();

        $sets = [
            'periodo' => function () use ($data) {

                $data->model['periodo'] = ['start' => null, 'end' => null];
            },
            'unidade' => function () use ($data, $params) {

                $unidadesData = self::getUnidadesData($params);

                $data->form['unidades'] = $unidadesData['form'];
                $data->model['unidade_id'] = $params->unidade_id = $unidadesData['model'];
            },
            'infraestrutura' => function () use ($data, $params) {

                $infraestruturasData = self::getInfraestruturasData($params);

                $data->form['infraestruturas'] = $infraestruturasData['form'];
                $data->model['infraestrutura_id'] = $params->infraestrutura_id = $infraestruturasData['model'];
            },
            'centro_custo' => function () use ($data, $params) {

                $centrosDeCustoData = self::getCentrosDeCustoData($params);

                $data->form['centros_custo'] = $centrosDeCustoData['form'];
                $data->model['centro_custo_id'] = $params->centro_custo_id = $centrosDeCustoData['model'];
            },
            'unidade_requisitante' => function () use ($data, $params) {

                $unidadesRequisitantesData = self::getUnidadesRequisitantesData($params);

                $data->form['unidades_requisitantes'] = $unidadesRequisitantesData['form'];
                $data->model['unidade_requisitante_id'] = $params->unidade_requisitante_id = $unidadesRequisitantesData['model'];
            },
            'infraestrutura_requisitante' => function () use ($data, $params) {

                $infraestruturasRequisitantesData = self::getInfraestruturasRequisitantesData($params);

                $data->form['infraestruturas_requisitantes'] = $infraestruturasRequisitantesData['form'];
                $data->model['infraestrutura_requisitante_id'] = $params->infraestrutura_requisitante_id = $infraestruturasRequisitantesData['model'];
            },
            'centro_custo_requisitante' => function () use ($data, $params) {

                $centrosDeCustoRequisitantesData = self::getCentrosDeCustoRequisitantesData($params);

                $data->form['centros_custo_requisitantes'] = $centrosDeCustoRequisitantesData['form'];
                $data->model['centro_custo_requisitante_id'] = $params->centro_custo_requisitante_id = $centrosDeCustoRequisitantesData['model'];
            },
            'usuario_requisitante' => function () use ($data, $params) {

                $usuariosRequisitantesData = self::getUsuariosRequisitantesData($params);

                $data->form['usuarios_requisitantes'] = $usuariosRequisitantesData['form'];
                $data->model['usuario_requisitante_id'] = $params->usuario_requisitante_id = $usuariosRequisitantesData['model'];
            },
            'status' => function () use ($data, $params) {

                $statusData = self::getStatusData($params);

                $data->form['status'] = $statusData['form'];
                $data->model['status'] =  $params->status = $statusData['model'];
            },
            'numero' => function () use ($data, $params) {

                $data->model['numero'] = $params->numero ?? null;
            },
            'grupo' => function () use ($data, $params) {

                $gruposData = self::getGruposData($params);

                $data->form['grupos'] = $gruposData['form'];
                $data->model['grupo_id'] = $params->grupo_id = $gruposData['model'];
            },
            'subgrupo' => function () use ($data, $params) {

                $subgruposData = self::getSubgruposData($params);

                $data->form['subgrupos'] = $subgruposData['form'];
                $data->model['subgrupo_id'] = $params->subgrupo_id = $subgruposData['model'];
            },
            'material' => function () use ($data, $params) {

                $data->model['material'] = $params->material_id = null;
            },
        ];

        $load = is_null(request()->load_from);

        if ($load) {

            $data->additionals = [
                'data_atual' => Carbon::now()->format('d/m/Y'),
            ];
        }

        foreach ($sets as $field => $set) {

            if ($load) {

                $set();
            }
            else if ($field === request()->load_from) {

                $load = true;
            }
        }

        foreach ($data as $property => $itens) {

            if (empty($itens)) {

                unset($data->{$property});
            }
        }

        return $data;
    }

    private static function getParams()
    {
        $params = (object) request()->only([
            'periodo',
            'unidade_id',
            'infraestrutura_id',
            'centro_custo_id',
            'unidade_requisitante_id',
            'infraestrutura_requisitante_id',
            'centro_custo_requisitante_id',
            'usuario_requisitante_id',
            'status',
            'numero',
            'grupo_id',
            'subgrupo_id',
        ]);

        if (isset($params->periodo)
            && !is_null($params->periodo['start'])
            && !is_null($params->periodo['end'])
        ) {

            $start = Carbon::createFromFormat('d/m/Y', $params->periodo['start'])->setTime(0, 0, 0);
            $end = Carbon::createFromFormat('d/m/Y', $params->periodo['end'])->setTime(23, 59, 59);

            $params->periodo['start'] = $start;
            $params->periodo['end'] = $end;
        }
        else {

            $params->periodo = null;
        }

        return $params;
    }

    private static function getUnidadesData($params)
    {
        $unidades = collect();
        $id = null;

        if (!is_null($params->periodo)) {

            $unidades = Unidade::setEagerLoads([])
                ->whereHas('infraestruturas', fn ($q) => $q
                    ->whereHas('centrosCusto', fn ($q) => self::setWhereForFilterCentroCustoAlmoxarifado($q, $params))
                )
                ->orderBy('nome_fantasia')
                ->get(['id', 'nome_fantasia']);
        }

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

    private static function getInfraestruturasData($params)
    {
        $infraestruturas = collect();
        $id = null;

        if (!is_null($params->periodo) && !is_null($params->unidade_id)) {

            $infraestruturas = Infraestrutura::setEagerLoads([])
                ->where('unidade_id', $params->unidade_id)
                ->whereHas('centrosCusto', fn ($q) => self::setWhereForFilterCentroCustoAlmoxarifado($q, $params))
                ->get(['id', 'nome', 'principal', 'unidade_id'])
                ->map(fn ($i) => ['id' => $i->id, 'nome' => $i->nome])
                ->sortBy('nome')
                ->values();
        }

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

    private static function getCentrosDeCustoData($params)
    {
        $centrosCusto = collect();
        $id = null;

        if (!is_null($params->periodo) && !is_null($params->infraestrutura_id)) {

            $centrosCusto = CentroCusto::setEagerLoads([])
                ->where('infraestrutura_id', $params->infraestrutura_id)
                ->where(fn ($q) => self::setWhereForFilterCentroCustoAlmoxarifado($q, $params))
                ->get(['id', 'setor_id'])
                ->map(fn ($cc) => [
                    'id' => $cc->id,
                    'setor_nome' => $cc->setor()->setEagerLoads([])->first(['nome'])->nome
                ])
                ->sortBy('setor_nome')
                ->values();
        }

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

    private static function setWhereForFilterCentroCustoAlmoxarifado($query, $params)
    {
        return $query->whereHas('almoxarifadoRequisicoes', fn ($q) => $q
            ->whereBetween('created_at', $params->periodo)
        );
    }

    private static function getUnidadesRequisitantesData($params)
    {
        $unidades = collect();
        $id = null;

        if (!is_null($params->periodo)) {

            $unidades = Unidade::setEagerLoads([])
                ->whereHas('infraestruturas', fn ($q) => $q
                    ->whereHas('centrosCusto', fn ($q) => self::setWhereForFilterCentroCustoRequisitante($q, $params))
                )
                ->orderBy('nome_fantasia')
                ->get(['id', 'nome_fantasia']);
        }

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

    private static function getInfraestruturasRequisitantesData($params)
    {
        $infraestruturas = collect();
        $id = null;

        if (!is_null($params->periodo) && !is_null($params->unidade_requisitante_id)) {

            $infraestruturas = Infraestrutura::setEagerLoads([])
                ->where('unidade_id', $params->unidade_requisitante_id)
                ->whereHas('centrosCusto', fn ($q) => self::setWhereForFilterCentroCustoRequisitante($q, $params))
                ->get(['id', 'nome', 'principal', 'unidade_id'])
                ->map(fn ($i) => ['id' => $i->id, 'nome' => $i->nome])
                ->sortBy('nome')
                ->values();
        }

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

    private static function getCentrosDeCustoRequisitantesData($params)
    {
        $centrosCusto = collect();
        $id = null;

        if (!is_null($params->periodo) && !is_null($params->infraestrutura_requisitante_id)) {

            $centrosCusto = CentroCusto::setEagerLoads([])
                ->where('infraestrutura_id', $params->infraestrutura_requisitante_id)
                ->where(fn ($q) => self::setWhereForFilterCentroCustoRequisitante($q, $params))
                ->get(['id', 'setor_id'])
                ->map(fn ($cc) => [
                    'id' => $cc->id,
                    'setor_nome' => $cc->setor()->setEagerLoads([])->first(['nome'])->nome
                ])
                ->sortBy('setor_nome')
                ->values();
        }

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

    private static function setWhereForFilterCentroCustoRequisitante($query, $params)
    {
        return $query->whereHas('almoxarifadoRequisicoesRequisitante', fn ($q) =>
            self::setWhereForSelectedCentroCustoAlmoxarifado($q, $params)
            ->whereBetween('created_at', $params->periodo)
        );
    }

    private static function getUsuariosRequisitantesData($params)
    {
        $usuarios = collect();
        $id = null;

        if (!is_null($params->periodo)) {

            $usuarios = Usuario::setEagerLoads([])
                ->whereHas('lotacoes', fn ($q) => $q
                    ->whereHas('almoxarifadoRequisicoesRequisitante', fn ($q) =>
                        self::setWhereForSelectedCentroCustoRequisitante(
                            self::setWhereForSelectedCentroCustoAlmoxarifado($q, $params),
                            $params
                        )
                        ->whereBetween('created_at', $params->periodo)
                    )
                )
                ->get(['id', 'cidadao_id'])
                ->map(fn ($u) => [
                    'id' => $u->id,
                    'nome' => $u->cidadao()->setEagerLoads([])->first(['nome'])->nome
                ])
                ->sortBy('nome')
                ->values();
        }

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

    private static function getStatusData($params)
    {
        $status = collect();
        $id = null;

        if (!is_null($params->periodo)) {

            $setWhereRequisicao = function ($query) use ($params) {

                return self::setWhereForSelectedCentroCustoRequisitante(
                    self::setWhereForSelectedCentroCustoAlmoxarifado($query, $params),
                    $params
                )
                ->whereBetween('created_at', $params->periodo)
                ->when($params->usuario_requisitante_id, fn ($q, $id) => $q
                    ->whereHas('createdLotacao', fn ($q) => $q->where('usuario_id', $id))
                );
            };

            $hasRequisicaoInStatus = function ($statusId) use ($setWhereRequisicao) {

                return Requisicao::setEagerLoads([])
                    ->where(fn ($q) => $setWhereRequisicao($q))
                    ->where('status_id', $statusId)
                    ->exists();
            };

            $hasRespostaInStatus = function ($statusId, $parcial = false) use ($setWhereRequisicao) {

                return Requisicao::setEagerLoads([])
                    ->where(fn ($q) => $setWhereRequisicao($q))
                    ->where('status_id', RequisicaoStatus::RESPOSTA_INICIADA)
                    ->whereRaw(self::getSqlStatus($statusId, $parcial))
                    ->exists();
            };

            if ($hasRequisicaoInStatus(RequisicaoStatus::ABERTA)) {

                $status->push((object) ['value' => 'aberta', 'text' => 'ABERTA']);
            }

            if ($hasRespostaInStatus(RequisicaoRespostaStatus::INICIADA)) {

                $status->push((object) ['value' => 'em_andamento', 'text' => 'EM ANDAMENTO']);
            }

            if ($hasRespostaInStatus(RequisicaoRespostaStatus::ENVIADA, true)) {

                $status->push((object) ['value' => 'enviado_parcial', 'text' => 'ENVIADO PARCIAL']);
            }

            if ($hasRespostaInStatus(RequisicaoRespostaStatus::ENVIADA)) {

                $status->push((object) ['value' => 'enviado', 'text' => 'ENVIADO']);
            }

            if ($hasRespostaInStatus(RequisicaoRespostaStatus::RECEBIDA, true)) {

                $status->push((object) ['value' => 'finalizada_parcial', 'text' => 'FINALIZADA PARCIAL']);
            }

            if ($hasRequisicaoInStatus(RequisicaoStatus::FINALIZADA)) {

                $status->push((object) ['value' => 'finalizada', 'text' => 'FINALIZADA']);
            }
        }

        return ['form' => $status->sortBy('text')->values(), 'model' => $id];
    }

    private static function getGruposData($params)
    {
        $grupos = collect();
        $id = null;

        if (!is_null($params->periodo)) {

            $grupos = Grupo::setEagerLoads([])
                ->whereHas('materiais', fn ($q) => self::setWhereForFilterMaterial($q, $params))
                ->orderBy('nome')
                ->get(['id', 'nome']);
        }

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

    private static function getSubgruposData($params)
    {
        $subgrupos = collect();
        $id = null;

        if (!is_null($params->periodo) && !is_null($params->grupo_id)) {

            $subgrupos = Subgrupo::setEagerLoads([])
                ->where('grupo_id', $params->grupo_id)
                ->whereHas('materiais', fn ($q) => self::setWhereForFilterMaterial($q, $params))
                ->orderBy('nome')
                ->get(['id', 'nome']);
        }

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

    public static function autocompleteMaterial()
    {
        $params = self::getParams();

        $materiais = Material::setEagerLoads([])
            ->when($params->grupo_id, fn ($q, $grupoId) => $q->where('grupo_id', $grupoId))
            ->when($params->subgrupo_id, fn ($q, $subgrupoId) => $q->where('subgrupo_id', $subgrupoId))
            ->where(fn ($q) => self::setWhereForFilterMaterial($q, $params))
            ->getQuery()
            ->join(
                'cadastro_apresentacao',
                'cadastro_apresentacao.id',
                'cadastro_material.apresentacao_id'
            )
            ->leftJoin(
                'cadastro_unidade_medida as apresentacao_unidade_medida',
                'apresentacao_unidade_medida.id',
                'cadastro_material.apresentacao_unidade_medida_id'
            )
            ->select(
                'cadastro_material.id',
                'cadastro_material.codigo_material',
                DB::raw(MaterialService::getDescricaoCompletaRaw(
                    'cadastro_material',
                    'cadastro_apresentacao',
                    'apresentacao_unidade_medida'
                ) . " as descricao"),
            );

        return $materiais;
    }

    public static function setWhereForFilterMaterial($query, $params)
    {
        return $query->whereHas('almoxarifadoRequisicaoItens', fn ($q) => $q
            ->whereHas('requisicao', fn ($q) =>
                self::setWhereForSelectedCentroCustoRequisitante(
                    self::setWhereForSelectedCentroCustoAlmoxarifado($q, $params),
                    $params
                )
                ->whereBetween('created_at', $params->periodo)
                ->when($params->numero, fn ($q, $numero) => $q->where('numero', $numero))
                ->when($params->usuario_requisitante_id, fn ($q, $id) => $q
                    ->whereHas('createdLotacao', fn ($q) => $q->where('usuario_id', $id))
                )
                ->when($params->status, function ($query, $status) {

                    if ($status == 'aberta') {

                        $query->where('status_id', RequisicaoStatus::ABERTA);
                    }
                    else if ($status == 'finalizada') {

                        $query->where('status_id', RequisicaoStatus::FINALIZADA);
                    }
                    else {

                        $query->where('status_id', RequisicaoStatus::RESPOSTA_INICIADA);

                        if ($status == 'em_andamento') {

                            $query->whereRaw(self::getSqlStatus(RequisicaoRespostaStatus::INICIADA));
                        }
                        else if ($status == 'enviado') {

                            $query->whereRaw(self::getSqlStatus(RequisicaoRespostaStatus::ENVIADA));
                        }
                        else if ($status == 'enviado_parcial') {

                            $query->whereRaw(self::getSqlStatus(RequisicaoRespostaStatus::ENVIADA, true));
                        }
                        else if ($status == 'finalizada_parcial') {

                            $query->whereRaw(self::getSqlStatus(RequisicaoRespostaStatus::RECEBIDA, true));
                        }
                    }
                })
            )
        );
    }

    private static function setWhereForSelectedCentroCustoAlmoxarifado($query, $params)
    {
        return $query->when($params->centro_custo_id,
            fn ($q, $centroCustoId) => $q->where('centro_custo_id', $centroCustoId),
            fn ($q) => $q->when(!is_null($params->infraestrutura_id) || !is_null($params->unidade_id),
                fn ($q) => $q->whereHas('centroCusto', fn ($q) => $q
                    ->when($params->infraestrutura_id,
                        fn ($q, $infraestruturaId) => $q->where('infraestrutura_id', $infraestruturaId),
                        fn ($q) => $q->whereHas('infraestrutura', fn ($q) => $q
                            ->where('unidade_id', $params->unidade_id))
                    )
                )
            )
        );
    }

    private static function setWhereForSelectedCentroCustoRequisitante($query, $params)
    {
        return $query->when($params->centro_custo_requisitante_id,
            fn ($q, $centroCustoId) => $q->where('created_centro_custo_id', $centroCustoId),
            fn ($q) => $q->when(!is_null($params->infraestrutura_requisitante_id) || !is_null($params->unidade_requisitante_id),
                fn ($q) => $q->whereHas('centroCusto', fn ($q) => $q
                    ->when($params->infraestrutura_requisitante_id,
                        fn ($q, $infraestruturaId) => $q->where('infraestrutura_id', $infraestruturaId),
                        fn ($q) => $q->whereHas('infraestrutura', fn ($q) => $q
                            ->where('unidade_id', $params->unidade_requisitante_id))
                    )
                )
            )
        );
    }

    public static function getPrintExportData()
    {
        $resultado = self::index();
        $itens = $resultado['requisicoes'];

        $itens->each(function ($item) {

            $item->data = (new Carbon($item->data))->format('d/m/Y');
        });

        $unidade = Unidade::find(request()->unidade_id);
        $infraestrutura = Infraestrutura::find(request()->infraestrutura_id);
        $centroCusto = CentroCusto::find(request()->centro_custo_id);
        $unidadeRequisitante = Unidade::find(request()->unidade_requisitante_id);
        $infraestruturaRequisitante = Infraestrutura::find(request()->infraestrutura_requisitante_id);
        $centroCustoRequisitante = CentroCusto::find(request()->centro_custo_requisitante_id);
        $usuarioRequisitante = Usuario::find(request()->usuario_requisitante_id);
        $grupo = Grupo::find(request()->grupo_id);
        $subgrupo = Subgrupo::find(request()->subgrupo_id);
        $material = Material::find(request()->material_id);

        return [
            'inicio' => request()->periodo['start'],
            'fim' => request()->periodo['end'],
            'unidade' => $unidade->nome_fantasia ?? 'Todas',
            'infraestrutura' => $infraestrutura->nome ?? 'Todos',
            'setor' => $centroCusto->setor->nome ?? 'Todos',
            'unidadeRequisitante' => $unidadeRequisitante->nome_fantasia ?? 'Todas',
            'infraestruturaRequisitante' => $infraestruturaRequisitante->nome ?? 'Todos',
            'setorRequisitante' => $centroCustoRequisitante->setor->nome ?? 'Todos',
            'usuarioRequisitante' => $usuarioRequisitante->nome ?? 'Todos',
            'status' => request()->status_descricao ?? 'Todos',
            'numero' => request()->numero ?? 'Todos',
            'grupo' => $grupo->nome ?? 'Todos',
            'subgrupo' => $subgrupo->nome ?? 'Todos',
            'material' => $material->descricao_completa ?? 'Todos',
            'colunas' => collect(request()->selectedCols),
            'requisicoes' => $itens,
            'withDetails' => DataUtil::getBooleanValueFromStringBoolean(request()->with_details),
        ];
    }

    private static function getSqlStatus($statusId, $parcial = false, $requisicaoAlias = 'almoxarifado_requisicao')
    {
        $whereResposta = $statusId == RequisicaoRespostaStatus::INICIADA
            ? ''
            : "AND " . ($parcial ? '' : 'NOT') . " EXISTS (
                SELECT      1
                FROM        almoxarifado_requisicao_resposta_item as item
                WHERE       item.requisicao_resposta_id = resposta.id
                AND         item.motivo_id IN (
                    " . RequisicaoRespostaItemMotivo::ENTREGA_PARCIAL . ",
                    " . RequisicaoRespostaItemMotivo::PENDENTE_DE_ENTREGA . "
                )
            )";

        return "(
            SELECT  resposta.status_id
            FROM    (
                SELECT  r.id,
                        r.status_id,
                        r.requisicao_id
                FROM    almoxarifado_requisicao_resposta r
                WHERE   (
                            (
                                SELECT  COUNT(r_sub.id)
                                FROM    almoxarifado_requisicao_resposta r_sub
                                WHERE   r_sub.requisicao_id = r.requisicao_id
                            ) = 1
                            OR
                            (
                                (
                                    SELECT  COUNT(r_sub.id)
                                    FROM    almoxarifado_requisicao_resposta r_sub
                                    WHERE   r_sub.requisicao_id = r.requisicao_id
                                ) > 1
                                AND
                                (
                                    (
                                        (
                                            SELECT      r_sub.status_id
                                            FROM        almoxarifado_requisicao_resposta r_sub
                                            WHERE       r_sub.requisicao_id = r.requisicao_id
                                            ORDER BY    r_sub.id DESC
                                            LIMIT       1
                                        ) = " . RequisicaoRespostaStatus::ENVIADA . "
                                        AND
                                        r.id = (
                                            SELECT  MIN(r_sub.id)
                                            FROM    almoxarifado_requisicao_resposta r_sub
                                            WHERE   r_sub.requisicao_id = r.requisicao_id
                                            AND     r_sub.status_id = " . RequisicaoRespostaStatus::ENVIADA . "
                                        )
                                    )
                                    OR
                                    (
                                        (
                                            (
                                                SELECT      r_sub.status_id
                                                FROM        almoxarifado_requisicao_resposta r_sub
                                                WHERE       r_sub.requisicao_id = r.requisicao_id
                                                ORDER BY    r_sub.id DESC
                                                LIMIT       1
                                            ) <> " . RequisicaoRespostaStatus::ENVIADA . "
                                            AND
                                            (
                                                SELECT      r_sub.status_id
                                                FROM        almoxarifado_requisicao_resposta r_sub
                                                WHERE       r_sub.requisicao_id = r.requisicao_id
                                                AND         r_sub.id <> (
                                                    SELECT      r_sub_sub.id
                                                    FROM        almoxarifado_requisicao_resposta r_sub_sub
                                                    WHERE       r_sub_sub.requisicao_id = r_sub.requisicao_id
                                                    ORDER BY    r_sub_sub.id DESC
                                                    LIMIT       1
                                                )
                                                ORDER BY    r_sub.id DESC
                                                LIMIT       1
                                            ) <> " . RequisicaoRespostaStatus::ENVIADA . "
                                        )
                                        AND
                                        r.id = (
                                            SELECT      r_sub.id
                                            FROM        almoxarifado_requisicao_resposta r_sub
                                            WHERE       r_sub.requisicao_id = r.requisicao_id
                                            ORDER BY    r_sub.id DESC
                                            LIMIT       1
                                        )
                                    )
                                    OR
                                    (
                                        (
                                            (
                                                SELECT      r_sub.status_id
                                                FROM        almoxarifado_requisicao_resposta r_sub
                                                WHERE       r_sub.requisicao_id = r.requisicao_id
                                                ORDER BY    r_sub.id DESC
                                                LIMIT       1
                                            ) <> " . RequisicaoRespostaStatus::ENVIADA . "
                                            AND
                                            (
                                                SELECT      r_sub.status_id
                                                FROM        almoxarifado_requisicao_resposta r_sub
                                                WHERE       r_sub.requisicao_id = r.requisicao_id
                                                AND         r_sub.id <> (
                                                    SELECT      r_sub_sub.id
                                                    FROM        almoxarifado_requisicao_resposta r_sub_sub
                                                    WHERE       r_sub_sub.requisicao_id = r_sub.requisicao_id
                                                    ORDER BY    r_sub_sub.id DESC
                                                    LIMIT       1
                                                )
                                                ORDER BY    r_sub.id DESC
                                                LIMIT       1
                                            ) = " . RequisicaoRespostaStatus::ENVIADA . "
                                        )
                                        AND
                                        r.id = (
                                            SELECT      r_sub.id
                                            FROM        almoxarifado_requisicao_resposta r_sub
                                            WHERE       r_sub.requisicao_id = r.requisicao_id
                                            AND         r_sub.id <> (
                                                SELECT      r_sub_sub.id
                                                FROM        almoxarifado_requisicao_resposta r_sub_sub
                                                WHERE       r_sub_sub.requisicao_id = r_sub.requisicao_id
                                                ORDER BY    r_sub_sub.id DESC
                                                LIMIT       1
                                            )
                                            ORDER BY    r_sub.id DESC
                                            LIMIT       1
                                        )
                                    )
                                )
                            )
                        )
            ) AS resposta
            WHERE   resposta.requisicao_id = {$requisicaoAlias}.id
            {$whereResposta}
        ) = {$statusId}";
    }
}