rapina.go

// SPDX-FileCopyrightText: 2023 Adriano Prado <dev@dude333.com>
//
// SPDX-License-Identifier: MIT

package rapina

import (
	"strings"

	"github.com/dude333/rapinav2/pkg/progress"
)

type InformeTrimestral struct {
	Codigo  string
	Descr   string
	Valores []ValoresTrimestrais
}

type ValoresTrimestrais struct {
	Ano int
	T1  float64
	T2  float64
	T3  float64
	T4  float64
}

// T retorna o valor do trimestre pelo índice (0 <= n < 4)
func (v *ValoresTrimestrais) T(n int) float64 {
	switch n {
	case 1:
		return v.T1
	case 2:
		return v.T2
	case 3:
		return v.T3
	case 4:
		return v.T4
	}
	return 0.0
}

// SetT salva o valor do trimestre pelo índice (0 <= n < 4)
func (v *ValoresTrimestrais) SetT(n int, val float64) {
	switch n {
	case 1:
		v.T1 = val
	case 2:
		v.T2 = val
	case 3:
		v.T3 = val
	case 4:
		v.T4 = val
	}
}

func (v ValoresTrimestrais) Add(other ValoresTrimestrais) ValoresTrimestrais {
	if v.Ano != other.Ano {
		return v
	}
	return ValoresTrimestrais{
		Ano: v.Ano,
		T1:  v.T1 + other.T1,
		T2:  v.T2 + other.T2,
		T3:  v.T3 + other.T3,
		T4:  v.T4 + other.T4,
	}
}

func (v ValoresTrimestrais) Sub(other ValoresTrimestrais) ValoresTrimestrais {
	if v.Ano != other.Ano {
		return v
	}
	return ValoresTrimestrais{
		Ano: v.Ano,
		T1:  v.T1 - other.T1,
		T2:  v.T2 - other.T2,
		T3:  v.T3 - other.T3,
		T4:  v.T4 - other.T4,
	}
}

func (v ValoresTrimestrais) Mult(other ValoresTrimestrais) ValoresTrimestrais {
	if v.Ano != other.Ano {
		return v
	}
	return ValoresTrimestrais{
		Ano: v.Ano,
		T1:  v.T1 * other.T1,
		T2:  v.T2 * other.T2,
		T3:  v.T3 * other.T3,
		T4:  v.T4 * other.T4,
	}
}

func (v ValoresTrimestrais) Div(other ValoresTrimestrais) ValoresTrimestrais {
	safeDiv := func(num, divisor float64) float64 {
		if divisor == 0 {
			return 0.0
		}
		return num / divisor
	}
	return ValoresTrimestrais{
		Ano: v.Ano,
		T1:  safeDiv(v.T1, other.T1),
		T2:  safeDiv(v.T2, other.T2),
		T3:  safeDiv(v.T3, other.T3),
		T4:  safeDiv(v.T4, other.T4),
	}
}

func (v ValoresTrimestrais) MultNum(factor float64) ValoresTrimestrais {
	return ValoresTrimestrais{
		Ano: v.Ano,
		T1:  v.T1 * factor,
		T2:  v.T2 * factor,
		T3:  v.T3 * factor,
		T4:  v.T4 * factor,
	}
}

func (v ValoresTrimestrais) DivNum(divisor float64) ValoresTrimestrais {
	if divisor == 0 {
		return ValoresTrimestrais{v.Ano, 0.0, 0.0, 0.0, 0.0}
	}
	return ValoresTrimestrais{
		Ano: v.Ano,
		T1:  v.T1 / divisor,
		T2:  v.T2 / divisor,
		T3:  v.T3 / divisor,
		T4:  v.T4 / divisor,
	}
}

func OpVTs(op rune, v1, v2 []ValoresTrimestrais) []ValoresTrimestrais {
	type par struct {
		// ano   int
		p1Idx int
		p2Idx int
		p1    bool
		p2    bool
	}
	anos := RangeAnosVTs(v1, v2)
	pares := make([]par, len(anos))
	for i := range v1 {
		pares[v1[i].Ano-anos[0]].p1 = true
		pares[v1[i].Ano-anos[0]].p1Idx = i
	}
	for j := range v2 {
		pares[v2[j].Ano-anos[0]].p2 = true
		pares[v2[j].Ano-anos[0]].p2Idx = j
	}
	v := make([]ValoresTrimestrais, 0, len(anos))
	for k := range anos {
		var p1Ptr, p2Ptr ValoresTrimestrais
		i := pares[k].p1Idx
		j := pares[k].p2Idx
		if pares[k].p1 && pares[k].p2 {
			p1Ptr = v1[i]
			p2Ptr = v2[j]
		} else if pares[k].p1 && !pares[k].p2 {
			p1Ptr = v1[i]
			p2Ptr = ValoresTrimestrais{v1[i].Ano, 0.0, 0.0, 0.0, 0.0}
		} else if !pares[k].p1 && pares[k].p2 {
			p1Ptr = ValoresTrimestrais{v2[j].Ano, 0.0, 0.0, 0.0, 0.0}
			p2Ptr = v2[j]
		} else {
			continue
		}

		r := ValoresTrimestrais{}
		switch op {
		case '+':
			r = p1Ptr.Add(p2Ptr)
		case '-':
			r = p1Ptr.Sub(p2Ptr)
		case '*':
			r = p1Ptr.Mult(p2Ptr)
		case '/':
			r = p1Ptr.Div(p2Ptr)
		}
		v = append(v, r)
	}
	return v
}

func AddVTs(v1, v2 []ValoresTrimestrais) []ValoresTrimestrais {
	return OpVTs('+', v1, v2)
}

func SubVTs(v1, v2 []ValoresTrimestrais) []ValoresTrimestrais {
	return OpVTs('-', v1, v2)
}

func MultVTs(v1, v2 []ValoresTrimestrais) []ValoresTrimestrais {
	return OpVTs('*', v1, v2)
}

func DivVTs(v1, v2 []ValoresTrimestrais) []ValoresTrimestrais {
	return OpVTs('/', v1, v2)
}

func codPai(codigo string) string {
	if len(codigo) < 1 {
		return codigo
	}
	lvl := strings.Count(codigo, ".") + 1
	if lvl <= 3 {
		return codigo
	}
	idx := strings.LastIndex(codigo, ".")
	if idx <= 0 {
		return codigo
	}
	return codigo[:idx]
}

// UnificarContasSimilares unifica as linhas similares do InformeTrimestral
// comparando o código, sem o último grupo (ex.: 1.02.05.01 => 1.02.05),
// com as próximas linhas.
// Cada linha (InformeTrimestral) possui o seguinte formato:
// Linha n => [Ano:ano Valor trimestre 1 | Valor T2 | Valor T3 | Valor T4]
// Exemplo:
// "Tributo a recuperar"  => [2019 1|0|5|3; 2021 5|2|0|0]
// "Tributos a recuperar" => [2019 0|2|0|0; 2020 1|4|2|2; 2021 0|0|1|2]
// Resultado:
// "Tributo a recuperar"  => [2019 1|2|5|3; 2020 1|4|2|2; 2021 5|2|1|2]
func UnificarContasSimilares(itr []InformeTrimestral) []InformeTrimestral {
	itrUnificado := make([]InformeTrimestral, 1, len(itr))
	unida := make([]bool, len(itr))
	anos := RangeAnos(itr, false)
	ultimaLinha := len(itr) - 1
	for linha1 := 0; linha1 <= ultimaLinha; linha1++ {
		if unida[linha1] {
			continue
		}
		valoresUnificados := itr[linha1].Valores
		for linha2 := linha1 + 1; linha2 <= ultimaLinha; linha2++ {
			if unida[linha2] {
				continue
			}
			cod1 := codPai(itr[linha1].Codigo)
			cod2 := codPai(itr[linha2].Codigo)
			if cod1 == cod2 && Similar(cod1+itr[linha1].Descr, cod2+itr[linha2].Descr) {
				unida[linha2] = true
				for _, ano := range anos {
					v1, existe1 := valorAno(ano, valoresUnificados)
					v2, existe2 := valorAno(ano, itr[linha2].Valores)

					if !existe1 && existe2 {
						valoresUnificados = append(valoresUnificados, v2)
					}
					if existe1 && existe2 {
						v, ok := equalizarValores(ano, v1, v2)
						unida[linha2] = ok
						if ok {
							valoresUnificados = append(valoresUnificados, v)
						} else {
							break
						}
					}
				} // next ano
				if unida[linha2] {
					progress.Trace("Joining:\n\t+ %v\n\t+ %v\n\t", itr[linha1], itr[linha2])
				}
			}
		} // next linha2
		informe := InformeTrimestral{
			Codigo:  itr[linha1].Codigo,
			Descr:   itr[linha1].Descr,
			Valores: valoresUnificados,
		}
		itrUnificado = append(itrUnificado, informe)
	} // next linha1
	return itrUnificado
}

func equalizarValores(ano int, v1, v2 ValoresTrimestrais) (ValoresTrimestrais, bool) {
	var v ValoresTrimestrais
	v.Ano = ano
	ok := true

	check := func(v1Tn, v2Tn float64) (float64, bool) {
		if !ok || (v1Tn != 0.0 && v2Tn != 0.0) {
			return 0.0, false
		}
		if v1Tn != 0.0 && v2Tn == 0.0 {
			return v1Tn, true
		}
		return v2Tn, true
	}

	v.T1, ok = check(v1.T1, v2.T1)
	v.T2, ok = check(v1.T2, v2.T2)
	v.T3, ok = check(v1.T3, v2.T3)
	v.T4, ok = check(v1.T4, v2.T4)

	return v, ok
}

func valorAno(ano int, valores []ValoresTrimestrais) (ValoresTrimestrais, bool) {
	for _, v := range valores {
		if v.Ano == ano {
			return v, true
		}
	}
	return ValoresTrimestrais{}, false
}

func Zerado(valores []ValoresTrimestrais) bool {
	for _, v := range valores {
		if v.T1 != 0 || v.T2 != 0 || v.T3 != 0 || v.T4 != 0 {
			return false
		}
	}
	return true
}

func TrimestresComDados(itr []InformeTrimestral) []bool {
	minAno, maxAno := MinMax(itr)
	colunas := make([]bool, 4*(1+maxAno-minAno))

	for _, informe := range itr {
		for ano := minAno; ano <= maxAno; ano++ {
			for _, v := range informe.Valores {
				if v.Ano != ano {
					continue
				}
				i := (v.Ano - minAno) * 4
				if !colunas[i+0] && v.T1 != 0.0 {
					colunas[i+0] = true
				}
				if v.T2 != 0.0 {
					colunas[i+1] = true
				}
				if v.T3 != 0.0 {
					colunas[i+2] = true
				}
				if v.T4 != 0.0 {
					colunas[i+3] = true
				}
			}
		}
	}
	return colunas
}

func MinMax(itr []InformeTrimestral) (int, int) {
	minAno := 99999
	maxAno := 0
	for i := range itr {
		for _, valores := range itr[i].Valores {
			if valores.Ano < minAno {
				minAno = valores.Ano
			}
			if valores.Ano > maxAno {
				maxAno = valores.Ano
			}
		}
	}
	if minAno > maxAno {
		return 0, 0
	}
	return minAno, maxAno
}

func RangeAnos(itr []InformeTrimestral, reverse bool) []int {
	min, max := MinMax(itr)
	seq := make([]int, max-min+1)

	if reverse {
		for i := max; i >= min; i-- {
			seq[max-i] = i
		}
		return seq
	}

	for i := min; i <= max; i++ {
		seq[i-min] = i
	}
	return seq
}

func RangeAnosVTs(v1, v2 []ValoresTrimestrais) []int {
	itr := []InformeTrimestral{
		{"", "", v1},
		{"", "", v2},
	}
	return RangeAnos(itr, false)
}

// ÚÚltimoTrimestre retorna o último trimestre com valor não nulo
func ÚltimoTrimestre(ano int, valores []ValoresTrimestrais) int {
	for _, valor := range valores {
		if valor.Ano != ano {
			continue
		}
		if valor.T4 != 0.0 {
			return 4
		} else if valor.T3 != 0.0 {
			return 3
		} else if valor.T2 != 0.0 {
			return 2
		}
	}
	return 1
}

// TTM armazena a soma dos últimos 4 trimestres em cada um dos trimestres; usado em métricas
// que comparam como valores do balanço patrimonial.
// Exemplo: ROE = Lucro Líq. dos últimos 12 meses / Patrim.Líq.
func TTM(acct []ValoresTrimestrais) []ValoresTrimestrais {
	min, max := MinMax([]InformeTrimestral{{Codigo: "", Descr: "", Valores: acct}})
	t := ÚltimoTrimestre(max, acct)

	valores := make([]float64, (max-min+1)*4)

	for ano := min; ano <= max; ano++ {
		for _, valor := range acct {
			if valor.Ano != ano {
				continue
			}
			idx := 4 * (ano - min)
			valores[idx+0] = valor.T1
			valores[idx+1] = valor.T2
			valores[idx+2] = valor.T3
			valores[idx+3] = valor.T4
		}
	}

	somaValores := func(from, to int) float64 {
		invalidParm := from < 0 || to >= len(valores) || from > to
		invalidPeriod := to >= (len(valores) - (4 - t))
		if invalidParm || invalidPeriod {
			return 0.0
		}

		total := 0.0
		for i := from; i <= to; i++ {
			total += valores[i]
		}
		return total
	}

	valoresAcum := make([]ValoresTrimestrais, (max-min+1)*4)

	for ano := min; ano <= max; ano++ {
		for _, valor := range acct {
			if valor.Ano != ano {
				continue
			}
			idx := 4 * (ano - min)
			valoresAcum[ano-min] = ValoresTrimestrais{
				Ano: ano,
				T1:  somaValores(idx-3, idx+0),
				T2:  somaValores(idx-2, idx+1),
				T3:  somaValores(idx-1, idx+2),
				T4:  somaValores(idx-0, idx+3),
			}
		}
	}

	return valoresAcum
}

// ManterÚltimoTrimestre mantém apenas o último trimestre não nulo de cada ano
func ManterÚltimoTrimestre(vts []ValoresTrimestrais) []ValoresTrimestrais {
	w := make([]ValoresTrimestrais, len(vts))
	for i, v := range vts {
		t := ÚltimoTrimestre(v.Ano, vts)
		w[i].Ano = v.Ano
		w[i].SetT(t, v.T(t))
	}
	return w
}