<?php

namespace App\Services\Almoxarifado;

use App\Exceptions\Almoxarifado\FechamentoBalanceteNaoPermitidoException;
use App\Models\Almoxarifado\BalanceteFechamento;
use App\Models\Cadastro\Grupo\Grupo;
use App\Models\Cadastro\OrigemProgramatica;
use App\Services\Cadastro\Material\MaterialService;
use App\Services\Service;
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;

class BalanceteService extends Service
{
    public static function checkDate($data)
    {
        $data = Carbon::createFromFormat('Y-m-d', $data)->setDay(1)->setTime(0, 0, 0);

        $mesFechado = BalanceteFechamento::where('ano', $data->year)
            ->where('mes', (int) $data->month)
            ->exists();

        if (!$mesFechado) {

            $primeiroBalancete = BalanceteFechamento::orderBy('ano')->orderBy('mes')->first();

            if (!is_null($primeiroBalancete)) {

                $dataPrimeiroBalancete = Carbon::create($primeiroBalancete->ano, $primeiroBalancete->mes);
                $mesFechado = $data <= $dataPrimeiroBalancete;
            }
        }

        return [
            'mes_fechado' => $mesFechado
        ];
    }

    public static function index()
    {
        $periodo = [
            'inicio' => Carbon::createFromFormat('d/m/Y', request()->inicio)->setTime(0, 0, 0),
            'fim' => Carbon::createFromFormat('d/m/Y', request()->fim)->setTime(23, 59, 59),
        ];

        $balancete = self::getBalancete($periodo, request()->grupo_id, request()->subgrupo_id, request()->origem_programatica_id);

        self::formatarSaldos($balancete);

        return $balancete;
    }

    public static function formatarSaldos($balancete)
    {
        $balancete['por_material']->each(function ($balancete) {

            $balancete->saldo_anterior_financeiro = self::getSaldoFormatado($balancete->saldo_anterior_financeiro);
            $balancete->saldo_entrada_financeiro = self::getSaldoFormatado($balancete->saldo_entrada_financeiro);
            $balancete->saldo_saida_financeiro = self::getSaldoFormatado($balancete->saldo_saida_financeiro);
            $balancete->saldo_atual_financeiro = self::getSaldoFormatado($balancete->saldo_atual_financeiro);

            unset($balancete->grupo_id, $balancete->subgrupo_id);
        });

        $balancete['por_subgrupo']->each(function ($balancete) {

            $balancete->saldo_anterior_financeiro = self::getSaldoFormatado($balancete->saldo_anterior_financeiro);
            $balancete->saldo_entrada_financeiro = self::getSaldoFormatado($balancete->saldo_entrada_financeiro);
            $balancete->saldo_saida_financeiro = self::getSaldoFormatado($balancete->saldo_saida_financeiro);
            $balancete->saldo_atual_financeiro = self::getSaldoFormatado($balancete->saldo_atual_financeiro);

            unset($balancete->grupo_id, $balancete->subgrupo_id);
        });

        $balancete['por_grupo']->each(function ($balancete) {

            $balancete->saldo_anterior_financeiro = self::getSaldoFormatado($balancete->saldo_anterior_financeiro);
            $balancete->saldo_entrada_financeiro = self::getSaldoFormatado($balancete->saldo_entrada_financeiro);
            $balancete->saldo_saida_financeiro = self::getSaldoFormatado($balancete->saldo_saida_financeiro);
            $balancete->saldo_atual_financeiro = self::getSaldoFormatado($balancete->saldo_atual_financeiro);

            unset($balancete->grupo_id);
        });

        $balancete['totalizadores']['saldo_anterior_financeiro'] = self::getSaldoFormatado(
            $balancete['totalizadores']['saldo_anterior_financeiro']
        );

        $balancete['totalizadores']['saldo_entrada_financeiro'] = self::getSaldoFormatado(
            $balancete['totalizadores']['saldo_entrada_financeiro']
        );

        $balancete['totalizadores']['saldo_saida_financeiro'] = self::getSaldoFormatado(
            $balancete['totalizadores']['saldo_saida_financeiro']
        );

        $balancete['totalizadores']['saldo_atual_financeiro'] = self::getSaldoFormatado(
            $balancete['totalizadores']['saldo_atual_financeiro']
        );
    }

    private static function getSaldoFormatado($valor)
    {
        $precisao = 2;
        $fator = (int) str_pad('1', $precisao + 1, '0');

        return number_format(floor($valor * $fator) / $fator, $precisao, ',', '.');
    }

    public static function list()
    {
        $dataUltimoBalanceteFechado = self::getDataUltimoBalanceteFechado();
        $dataBalanceteAberto = self::getDataBalanceteAberto();

        if (!is_null($dataUltimoBalanceteFechado)) {

            $dataUltimoBalanceteFechado = $dataUltimoBalanceteFechado->translatedFormat('F \de Y');
        }

        return [
            'additionals' => [
                'data_atual' => Carbon::now()->format('d/m/Y'),
                'data_ultimo_balancete_fechado' => $dataUltimoBalanceteFechado,
                'data_balancete_aberto' => self::getDataBalanceteAberto()->translatedFormat('F \de Y'),
                'permite_fechar' => !$dataBalanceteAberto->isCurrentMonth(),
            ],
            'form' => [
                'grupos' => Grupo::orderBy('nome')
                    ->get()
                    ->map(fn ($grupo) => [
                        'id' => $grupo->id,
                        'nome' => $grupo->nome,
                        'subgrupos' => $grupo->subgrupos()
                            ->orderBy('nome')
                            ->get(['id', 'nome'])
                    ]),
                'origens_programaticas' => OrigemProgramatica::orderBy('nome')->get(['id', 'nome']),
            ],
            'model' => [
                'periodo' => [
                    'start' => null,
                    'end' => null,
                ],
                'grupo_id' => null,
                'subgrupo_id' => null,
                'origem_programatica_id' => null,
            ],
        ];
    }

    public static function store()
    {
        $dataBalanceteAberto = self::getDataBalanceteAberto();
        $saldo = self::getSaldo($dataBalanceteAberto);

        if ($dataBalanceteAberto->isCurrentMonth()) {

            throw new FechamentoBalanceteNaoPermitidoException;
        }

        return BalanceteFechamento::create([
            'mes' => $dataBalanceteAberto->month,
            'ano' => $dataBalanceteAberto->year,
            'saldo_fisico' => $saldo['fisico'],
            'saldo_financeiro' => $saldo['financeiro'],
        ]);
    }

    private static function getSaldo($dataBalanceteAberto)
    {
        $totais = self::getBalancete([
            'inicio' => $dataBalanceteAberto->modify('first day of this month')->setTime(0, 0, 0),
            'fim' => $dataBalanceteAberto->copy()->modify('last day of this month')->setTime(23, 59, 59),
        ])['totalizadores'];

        return [
            'fisico' => $totais['saldo_atual_fisico'],
            'financeiro' => $totais['saldo_atual_financeiro'],
        ];
    }

    public static function getBalancete($periodo, $grupoId = null, $subgrupoId = null, $origemProgramaticaId = null)
    {
        $inicio = $periodo['inicio'];
        $fim = $periodo['fim'];
        $periodo = [$inicio, $fim];

        $totalizadores = collect([
            'saldo_anterior_fisico' => 0,
            'saldo_anterior_financeiro' => 0.0,
            'saldo_entrada_fisico' => 0,
            'saldo_entrada_financeiro' => 0.0,
            'saldo_saida_fisico' => 0,
            'saldo_saida_financeiro' => 0.0,
            'saldo_atual_fisico' => 0,
            'saldo_atual_financeiro' => 0.0,
        ]);

        $balancetePorGrupo = collect();
        $balancetePorSubgrupo = collect();

        $balancetePorMaterial = DB::table('cadastro_material as material')
            ->join('cadastro_apresentacao as apresentacao', 'apresentacao.id', 'material.apresentacao_id')
            ->join('cadastro_grupo as grupo', 'grupo.id', 'material.grupo_id')
            ->leftJoin(
                'cadastro_unidade_medida as apresentacao_unidade_medida',
                'apresentacao_unidade_medida.id',
                'material.apresentacao_unidade_medida_id'
            )
            ->leftJoin('cadastro_subgrupo as subgrupo', 'subgrupo.id', 'material.subgrupo_id')
            ->whereNull('material.deleted_at')
            ->when($grupoId, fn ($q, $id) => $q->where('material.grupo_id', $id))
            ->when($subgrupoId, fn ($q, $id) => $q->where('material.subgrupo_id', $id))
            ->where(function ($query) use ($periodo, $origemProgramaticaId, $inicio) {

                $query
                    ->whereExists(function ($query) use ($periodo, $origemProgramaticaId) {

                        $query->select(DB::raw(1))
                            ->from('almoxarifado_entrada_item as entrada_item')
                            ->join('almoxarifado_entrada as entrada', 'entrada.id', 'entrada_item.entrada_id')
                            ->whereColumn('entrada_item.material_id', 'material.id')
                            ->where('entrada.finalizada', true)
                            ->where(function ($query) use ($periodo, $origemProgramaticaId) {

                                $query
                                    ->whereExists(function ($query) use ($periodo, $origemProgramaticaId) {

                                        $query->select(DB::raw(1))
                                            ->from('almoxarifado_entrada_documento as documento')
                                            ->whereColumn('documento.entrada_id', 'entrada.id')
                                            ->whereBetween('documento.data', $periodo)
                                            ->when($origemProgramaticaId, fn ($q, $id) => $q->where('documento.origem_programatica_id', $id));
                                    })
                                    ->when(is_null($origemProgramaticaId), function ($query) use ($periodo) {

                                        $query
                                            ->orWhere(function ($query) use ($periodo) {

                                                $query
                                                    ->whereNotExists(function ($query) {

                                                        $query->select(DB::raw(1))
                                                            ->from('almoxarifado_entrada_documento as documento')
                                                            ->whereColumn('documento.entrada_id', 'entrada.id');
                                                    })
                                                    ->whereBetween('entrada.created_at', $periodo);
                                            });
                                    });
                            });
                    })
                    ->orWhereExists(function ($query) use ($periodo, $origemProgramaticaId) {

                        $query->select(DB::raw(1))
                            ->from('almoxarifado_saida_item as saida_item')
                            ->join('almoxarifado_saida as saida', 'saida.id', 'saida_item.saida_id')
                            ->whereColumn('saida_item.material_id', 'material.id')
                            ->where('saida.finalizada', true)
                            ->whereBetween('saida.created_at', $periodo)
                            ->when(!is_null($origemProgramaticaId), function ($query) use ($origemProgramaticaId) {

                                $query->whereExists(fn ($q) => $q
                                    ->selectRaw(1)
                                    ->from('almoxarifado_saida_item_entrada_item as saida_item_entrada_item')
                                    ->join('almoxarifado_entrada_item as entrada_item', 'entrada_item.id', 'saida_item_entrada_item.entrada_item_id')
                                    ->join('almoxarifado_entrada as entrada', 'entrada.id', 'entrada_item.entrada_id')
                                    ->join('almoxarifado_entrada_documento as entrada_documento', 'entrada_documento.entrada_id', 'entrada.id')
                                    ->whereColumn('saida_item_entrada_item.saida_item_id', 'saida_item.id')
                                    ->where('entrada_documento.origem_programatica_id', $origemProgramaticaId)
                                );
                            });
                    })
                    ->orWhereExists(function ($query) use ($inicio, $origemProgramaticaId) {

                        $query->select(DB::raw(1))
                            ->from('almoxarifado_entrada_item as entrada_item')
                            ->join('almoxarifado_entrada as entrada', 'entrada.id', 'entrada_item.entrada_id')
                            ->whereColumn('entrada_item.material_id', 'material.id')
                            ->where('entrada.finalizada', true)
                            ->where(function ($q) use ($inicio, $origemProgramaticaId) {
                                $q->whereExists(function ($q2) use ($inicio, $origemProgramaticaId) {
                                    $q2->select(DB::raw(1))
                                        ->from('almoxarifado_entrada_documento as documento')
                                        ->whereColumn('documento.entrada_id', 'entrada.id')
                                        ->where('documento.data', '<', $inicio)
                                        ->when($origemProgramaticaId, fn ($f, $id) =>
                                        $f->where('documento.origem_programatica_id', $id)
                                    );
                                })
                                ->when(is_null($origemProgramaticaId), function ($q2) use ($inicio) {
                                    $q2->orWhere(function ($q3) use ($inicio) {
                                        $q3->whereNotExists(function ($q4) {
                                            $q4->select(DB::raw(1))
                                                ->from('almoxarifado_entrada_documento as documento')
                                                ->whereColumn('documento.entrada_id', 'entrada.id');
                                        })
                                        ->where('entrada.created_at', '<', $inicio);
                                    });
                                });
                        });
                    });
            })
            ->select(
                'material.codigo_material as material_codigo',
                DB::raw(MaterialService::getDescricaoCompletaRaw(
                    'material',
                    'apresentacao',
                    'apresentacao_unidade_medida'
                ) . " as material_descricao"),
                'grupo.id as grupo_id',
                'grupo.nome as grupo_nome',
                'subgrupo.id as subgrupo_id',
                'subgrupo.nome as subgrupo_nome'
            )
            ->addSelect([
                'saldo_anterior_fisico' => function ($query) use ($inicio, $origemProgramaticaId) {

                    $query->selectRaw("COALESCE((
                        SELECT      SUM(entrada_item.quantidade - COALESCE((
                                        SELECT      SUM(COALESCE(saida_item_entrada_item.quantidade_saida, 0))
                                        FROM        almoxarifado_saida_item_entrada_item AS saida_item_entrada_item
                                        WHERE       saida_item_entrada_item.entrada_item_id = entrada_item.id
                                        AND         EXISTS (
                                                        SELECT  1
                                                        FROM    almoxarifado_saida_item AS saida_item
                                                        JOIN    almoxarifado_saida AS saida
                                                        ON      saida.id = saida_item.saida_id
                                                        WHERE   saida_item.id = saida_item_entrada_item.saida_item_id
                                                        AND     saida.finalizada = 1
                                                        AND     saida.created_at < '{$inicio}'
                                                    )
                                    ), 0))
                        FROM        almoxarifado_entrada_item AS entrada_item
                        JOIN        almoxarifado_entrada AS entrada
                        ON          entrada.id = entrada_item.entrada_id
                        WHERE       entrada_item.material_id = material.id
                        AND         entrada.finalizada = 1
                        AND         (
                                        EXISTS (
                                            SELECT  1
                                            FROM    almoxarifado_entrada_documento AS documento
                                            WHERE   documento.entrada_id = entrada.id
                                            AND     documento.data < '{$inicio}'
                                            AND     documento.data IS NOT NULL
                                            " . (is_null($origemProgramaticaId) ? '' : "AND documento.origem_programatica_id = {$origemProgramaticaId}") . "
                                        )
                                        " . (is_null($origemProgramaticaId)
                                            ? "or (
                                                NOT EXISTS (
                                                    SELECT  1
                                                    FROM    almoxarifado_entrada_documento AS documento
                                                    WHERE   documento.entrada_id = entrada.id
                                                    AND     documento.data IS NOT NULL
                                                )
                                                AND entrada.created_at < '{$inicio}'
                                            )"
                                            : '')
                                        . "
                                    )
                        ), 0)");
                },
                'saldo_anterior_financeiro' => function ($query) use ($inicio, $origemProgramaticaId) {

                    $query->selectRaw("COALESCE((
                        SELECT      SUM((entrada_item.quantidade * entrada_item.valor_unitario) - COALESCE((
                                        SELECT      SUM(COALESCE(saida_item_entrada_item.quantidade_saida * entrada_item.valor_unitario, 0))
                                        FROM        almoxarifado_saida_item_entrada_item AS saida_item_entrada_item
                                        WHERE       saida_item_entrada_item.entrada_item_id = entrada_item.id
                                        AND         EXISTS (
                                                        SELECT  1
                                                        FROM    almoxarifado_saida_item AS saida_item
                                                        JOIN    almoxarifado_saida AS saida
                                                        ON      saida.id = saida_item.saida_id
                                                        WHERE   saida_item.id = saida_item_entrada_item.saida_item_id
                                                        AND     saida.finalizada = 1
                                                        AND     saida.created_at < '{$inicio}'
                                                    )
                                    ), 0))
                        FROM        almoxarifado_entrada_item AS entrada_item
                        JOIN        almoxarifado_entrada AS entrada
                        ON          entrada.id = entrada_item.entrada_id
                        WHERE       entrada_item.material_id = material.id
                        AND         entrada.finalizada = 1
                        AND         (
                                        EXISTS (
                                            SELECT  1
                                            FROM    almoxarifado_entrada_documento AS documento
                                            WHERE   documento.entrada_id = entrada.id
                                            AND     documento.data < '{$inicio}'
                                            AND     documento.data IS NOT NULL
                                            " . (is_null($origemProgramaticaId) ? '' : "AND documento.origem_programatica_id = {$origemProgramaticaId}") . "
                                        )
                                        " . (is_null($origemProgramaticaId)
                                            ? "or (
                                                NOT EXISTS (
                                                    SELECT  1
                                                    FROM    almoxarifado_entrada_documento AS documento
                                                    WHERE   documento.entrada_id = entrada.id
                                                    AND     documento.data IS NOT NULL
                                                )
                                                AND entrada.created_at < '{$inicio}'
                                            )"
                                            : '')
                                        . "
                                    )
                        ), 0)");
                },
                'saldo_entrada_fisico' => function ($query) use ($periodo, $origemProgramaticaId) {

                    $query->select(DB::raw('COALESCE(SUM(entrada_item.quantidade), 0)'))
                        ->from('almoxarifado_entrada_item as entrada_item')
                        ->join('almoxarifado_entrada as entrada', 'entrada.id', 'entrada_item.entrada_id')
                        ->whereColumn('entrada_item.material_id', 'material.id')
                        ->where('entrada.finalizada', true)
                        ->where(function ($query) use ($periodo, $origemProgramaticaId) {

                            $query
                                ->whereExists(function ($query) use ($periodo, $origemProgramaticaId) {

                                    $query->select(DB::raw(1))
                                        ->from('almoxarifado_entrada_documento as documento')
                                        ->whereColumn('documento.entrada_id', 'entrada.id')
                                        ->whereBetween('documento.data', $periodo)
                                        ->when($origemProgramaticaId, fn ($q, $id) => $q->where('documento.origem_programatica_id', $id));
                                })
                                ->when(is_null($origemProgramaticaId), function ($query) use ($periodo) {

                                    $query
                                        ->orWhere(function ($query) use ($periodo) {

                                            $query
                                                ->whereNotExists(function ($query) {

                                                    $query->select(DB::raw(1))
                                                        ->from('almoxarifado_entrada_documento as documento')
                                                        ->whereColumn('documento.entrada_id', 'entrada.id')
                                                        ->whereNotNull('documento.data');
                                                })
                                                ->whereBetween('entrada.created_at', $periodo);
                                        });
                                });
                        });
                },
                'saldo_entrada_financeiro' => function ($query) use ($periodo, $origemProgramaticaId) {

                    $query->select(DB::raw('COALESCE(SUM(entrada_item.quantidade * entrada_item.valor_unitario), 0)'))
                        ->from('almoxarifado_entrada_item as entrada_item')
                        ->join('almoxarifado_entrada as entrada', 'entrada.id', 'entrada_item.entrada_id')
                        ->whereColumn('entrada_item.material_id', 'material.id')
                        ->where('entrada.finalizada', true)
                        ->where(function ($query) use ($periodo, $origemProgramaticaId) {

                            $query
                                ->whereExists(function ($query) use ($periodo, $origemProgramaticaId) {

                                    $query->select(DB::raw(1))
                                        ->from('almoxarifado_entrada_documento as documento')
                                        ->whereColumn('documento.entrada_id', 'entrada.id')
                                        ->whereBetween('documento.data', $periodo)
                                        ->when($origemProgramaticaId, fn ($q, $id) => $q->where('documento.origem_programatica_id', $id));
                                })
                                ->when(is_null($origemProgramaticaId), function ($query) use ($periodo) {

                                    $query
                                        ->orWhere(function ($query) use ($periodo) {

                                            $query
                                                ->whereNotExists(function ($query) {

                                                    $query->select(DB::raw(1))
                                                        ->from('almoxarifado_entrada_documento as documento')
                                                        ->whereColumn('documento.entrada_id', 'entrada.id');
                                                })
                                                ->whereBetween('entrada.created_at', $periodo);
                                        });
                                });
                        });
                },
                'saldo_saida_fisico' => function ($query) use ($periodo, $origemProgramaticaId) {

                    $query->select(DB::raw('COALESCE(SUM(saida_item_entrada_item.quantidade_saida), 0)'))
                        ->from('almoxarifado_saida_item_entrada_item as saida_item_entrada_item')
                        ->join(
                            'almoxarifado_saida_item as saida_item',
                            'saida_item.id',
                            'saida_item_entrada_item.saida_item_id'
                        )
                        ->join('almoxarifado_saida as saida', 'saida.id', 'saida_item.saida_id')
                        ->whereColumn('saida_item.material_id', 'material.id')
                        ->where('saida.finalizada', true)
                        ->whereBetween('saida.created_at', $periodo)
                        ->when(!is_null($origemProgramaticaId), function ($query) use ($origemProgramaticaId) {

                            $query->whereExists(fn ($q) => $q
                                ->selectRaw(1)
                                ->from('almoxarifado_entrada_item as entrada_item')
                                ->join('almoxarifado_entrada as entrada', 'entrada.id', 'entrada_item.entrada_id')
                                ->join('almoxarifado_entrada_documento as entrada_documento', 'entrada_documento.entrada_id', 'entrada.id')
                                ->whereColumn('entrada_item.id', 'saida_item_entrada_item.entrada_item_id')
                                ->where('entrada_documento.origem_programatica_id', $origemProgramaticaId)
                            );
                        });
                },
                'saldo_saida_financeiro' => function ($query) use ($periodo, $origemProgramaticaId) {

                    $query->select(DB::raw(
                            'COALESCE(SUM(saida_item_entrada_item.quantidade_saida * entrada_item.valor_unitario), 0)'
                        ))
                        ->from('almoxarifado_entrada_item as entrada_item')
                        ->join(
                            'almoxarifado_saida_item_entrada_item as saida_item_entrada_item',
                            'saida_item_entrada_item.entrada_item_id',
                            'entrada_item.id'
                        )
                        ->join(
                            'almoxarifado_saida_item as saida_item',
                            'saida_item.id',
                            'saida_item_entrada_item.saida_item_id'
                        )
                        ->join('almoxarifado_saida as saida', 'saida.id', 'saida_item.saida_id')
                        ->whereColumn('saida_item.material_id', 'material.id')
                        ->where('saida.finalizada', true)
                        ->whereBetween('saida.created_at', $periodo)
                        ->when(!is_null($origemProgramaticaId), function ($query) use ($origemProgramaticaId) {

                            $query->whereExists(fn ($q) => $q
                                ->selectRaw(1)
                                ->from('almoxarifado_entrada as entrada')
                                ->join('almoxarifado_entrada_documento as entrada_documento', 'entrada_documento.entrada_id', 'entrada.id')
                                ->whereColumn('entrada.id', 'entrada_item.entrada_id')
                                ->where('entrada_documento.origem_programatica_id', $origemProgramaticaId)
                            );
                        });
                }
            ])
            ->get()
            ->map(function ($item) use ($balancetePorSubgrupo, $balancetePorGrupo, $totalizadores) {

                $item->saldo_atual_fisico = $item->saldo_anterior_fisico
                    + $item->saldo_entrada_fisico
                    - $item->saldo_saida_fisico;

                $item->saldo_atual_financeiro = $item->saldo_anterior_financeiro
                    + $item->saldo_entrada_financeiro
                    - $item->saldo_saida_financeiro;

                self::addBalancetePorSubgrupo($balancetePorSubgrupo, $item);
                self::addBalancetePorGrupo($balancetePorGrupo, $item);

                $totalizadores['saldo_anterior_fisico'] += $item->saldo_anterior_fisico;
                $totalizadores['saldo_anterior_financeiro'] += $item->saldo_anterior_financeiro;
                $totalizadores['saldo_entrada_fisico'] += $item->saldo_entrada_fisico;
                $totalizadores['saldo_entrada_financeiro'] += $item->saldo_entrada_financeiro;
                $totalizadores['saldo_saida_fisico'] += $item->saldo_saida_fisico;
                $totalizadores['saldo_saida_financeiro'] += $item->saldo_saida_financeiro;
                $totalizadores['saldo_atual_fisico'] += $item->saldo_atual_fisico;
                $totalizadores['saldo_atual_financeiro'] += $item->saldo_atual_financeiro;

                return $item;
            });

        return collect([
            'por_material' => $balancetePorMaterial,
            'por_subgrupo' => $balancetePorSubgrupo,
            'por_grupo' => $balancetePorGrupo,
            'totalizadores' => $totalizadores,
        ]);
    }

    private static function addBalancetePorSubgrupo($balancetePorSubgrupo, $item)
    {
        $balancetePorSubgrupoItem = $balancetePorSubgrupo
            ->where('grupo_id', $item->grupo_id)
            ->where('subgrupo_id', $item->subgrupo_id)
            ->first();

        if (is_null($balancetePorSubgrupoItem)) {

            $balancetePorSubgrupoItem = (object) [
                'grupo_id' => $item->grupo_id,
                'subgrupo_id' => $item->subgrupo_id,
                'subgrupo_nome' => $item->subgrupo_nome,
                'grupo_nome' => $item->grupo_nome,
                'saldo_anterior_fisico' => 0,
                'saldo_anterior_financeiro' => 0.0,
                'saldo_entrada_fisico' => 0,
                'saldo_entrada_financeiro' => 0.0,
                'saldo_saida_fisico' => 0,
                'saldo_saida_financeiro' => 0.0,
                'saldo_atual_fisico' => 0,
                'saldo_atual_financeiro' => 0.0,
            ];

            $balancetePorSubgrupo->push($balancetePorSubgrupoItem);
        }

        $balancetePorSubgrupoItem->saldo_anterior_fisico += $item->saldo_anterior_fisico;
        $balancetePorSubgrupoItem->saldo_anterior_financeiro += $item->saldo_anterior_financeiro;
        $balancetePorSubgrupoItem->saldo_entrada_fisico += $item->saldo_entrada_fisico;
        $balancetePorSubgrupoItem->saldo_entrada_financeiro += $item->saldo_entrada_financeiro;
        $balancetePorSubgrupoItem->saldo_saida_fisico += $item->saldo_saida_fisico;
        $balancetePorSubgrupoItem->saldo_saida_financeiro += $item->saldo_saida_financeiro;
        $balancetePorSubgrupoItem->saldo_atual_fisico += $item->saldo_atual_fisico;
        $balancetePorSubgrupoItem->saldo_atual_financeiro += $item->saldo_atual_financeiro;
    }

    private static function addBalancetePorGrupo($balancetePorGrupo, $item)
    {
        $balancetePorGrupoItem = $balancetePorGrupo->firstWhere('grupo_id', $item->grupo_id);

        if (is_null($balancetePorGrupoItem)) {

            $balancetePorGrupoItem = (object) [
                'grupo_id' => $item->grupo_id,
                'grupo_nome' => $item->grupo_nome,
                'saldo_anterior_fisico' => 0,
                'saldo_anterior_financeiro' => 0.0,
                'saldo_entrada_fisico' => 0,
                'saldo_entrada_financeiro' => 0.0,
                'saldo_saida_fisico' => 0,
                'saldo_saida_financeiro' => 0.0,
                'saldo_atual_fisico' => 0,
                'saldo_atual_financeiro' => 0.0,
            ];

            $balancetePorGrupo->push($balancetePorGrupoItem);
        }

        $balancetePorGrupoItem->saldo_anterior_fisico += $item->saldo_anterior_fisico;
        $balancetePorGrupoItem->saldo_anterior_financeiro += $item->saldo_anterior_financeiro;
        $balancetePorGrupoItem->saldo_entrada_fisico += $item->saldo_entrada_fisico;
        $balancetePorGrupoItem->saldo_entrada_financeiro += $item->saldo_entrada_financeiro;
        $balancetePorGrupoItem->saldo_saida_fisico += $item->saldo_saida_fisico;
        $balancetePorGrupoItem->saldo_saida_financeiro += $item->saldo_saida_financeiro;
        $balancetePorGrupoItem->saldo_atual_fisico += $item->saldo_atual_fisico;
        $balancetePorGrupoItem->saldo_atual_financeiro += $item->saldo_atual_financeiro;
    }

    private static function getDataUltimoBalanceteFechado()
    {
        $balancete = self::getUltimoBalanceteFechado();

        return is_null($balancete) ? null : Carbon::create($balancete->ano, $balancete->mes);
    }

    private static function getDataBalanceteAberto()
    {
        $ultimoBalanceteFechado = self::getUltimoBalanceteFechado();

        return is_null($ultimoBalanceteFechado)
            ? Carbon::now()->day(1)->subMonths(3)
            : Carbon::create($ultimoBalanceteFechado->ano, $ultimoBalanceteFechado->mes)
                ->modify('last day of this month')
                ->addDay();
    }

    private static function getUltimoBalanceteFechado()
    {
        return BalanceteFechamento::orderByDesc('ano')
            ->orderByDesc('mes')
            ->first();
    }
}