pdvshell

#!/usr/bin/env bash
#	shellcheck shell=bash disable=SC1091,SC2039,SC2166,SC2162,SC2155,SC2005,SC2034,SC2154,SC2229

#	pdvshell - Simples frente de caixa escrito em shell script e sqlite!
#	Created: 2023/10/21
#	Altered: 2024/11/20 - 02:21 -04
#	Updated: sex 14 ago 2026 03:24:37 -04
#
# Copyright (c) 2023-2026, Vilmar Catafesta <vcatafesta@gmail.com>
# Copyright (c) 2023-2023, Jefferson Carneiro <slackjeff>
# All rights reserved.
#
#	Redistribution and use in source and binary forms, with or without
#	modification, are permitted provided that the following conditions
#	are met:
#	1. 	Redistributions of source code must retain the above copyright
#		notice, this list of conditions and the following disclaimer.
#	2. 	Redistributions in binary form must reproduce the above copyright
# 		notice, this list of conditions and the following disclaimer in the
#		documentation and/or other materials provided with the distribution.
#
#	THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
#	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
#	OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

#	IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
#	INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
#	NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
#	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
#	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
#	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
#	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
################################################################################
export TEXTDOMAINDIR=/usr/share/locale
export TEXTDOMAIN=pdvshell
#
declare APP="${0##*/}"
declare _VERSION_="0.08.12-20260812"
declare _SYSTEM_="PDVSHELL"
declare _SYSTEM_DESC="$(gettext "Simples frente de caixa escrito em shell script e sqlite")"
declare database='pdvshell.db'
declare INI_FILE="pdvshell.ini"
trap 'cleanup' INT TERM HUP
declare -A Aempresa=(
	[razao]='EMPRESA MODELO LTDA'
	[ende]='Rua Modelo, 693 - Bairro Centro'
	[cida]='Cidade Modelo'
	[uf]='UF'
	[cnpj]='00.000.000/0001-00'
)
declare -a DEPENDENCIES=(
	tput
	gettext
	sqlite3
	bc
	tr
	sed
	awk
	figlet
)
declare -A PACKAGEDEP=(
	['tput']='ncurses'
	['gettext']='gettext'
	['sqlite3']='sqlite'
	['bc']='bc'
	['tr']='coreutils'
	['sed']='sed'
	['awk']='gawk'
	['figlet']='figlet'
)
readonly K_UP=5     # Ctrl-E
readonly K_DOWN=24  # Ctrl-X
readonly K_LEFT=19  # Ctrl-S
readonly K_RIGHT=4  # Ctrl-D
readonly K_HOME=1   # Ctrl-A
readonly K_END=6    # Ctrl-F
readonly K_PGUP=18  # Ctrl-R
readonly K_PGDN=3   # Ctrl-C
readonly K_ENTER=13 # Enter
readonly K_ESC=27   # Esc

# BEGIN FUNCTIONS
function cleanup() {
	tput sgr0
	tput clear
	info_msg "${red}Interrompido! Saindo...${reset}"
	info_msg "Desativando cores..."
	sh_unsetvarcolors
	exit 1
}

function sh_config() {
	declare COL_NC='\e[0m' # No Color
	declare COL_LIGHT_GREEN='\e[1;32m'
	declare COL_LIGHT_RED='\e[1;31m'
	declare -g TICK="${white}[${COL_LIGHT_GREEN}✓${COL_NC}${white}]"
	declare -g CROSS="${white}[${COL_LIGHT_RED}✗${COL_NC}${white}]"
	declare -gi lastrow=$(lastrow)
	declare -gi lastcol=$(lastcol)
	declare -gi Prow=0
	declare -gi Pcol=0
	declare -gi LC_DEFAULT=0
	declare -gi nTop=8
	declare -gi nLeft
	declare -gi nBottom
	declare -gi nRight
	declare -g Mercearia='Mercearia'
	declare -g Menu_Principal="$(gettext "Menu Principal")"
	declare -g Nenhum_produto_encontrado_nos_parametros_informados="$(gettext "Nenhum produto encontrado nos parâmetros informados")"
	declare -g Produtos="$(gettext "Produtos")"
	declare -g Fornecedores="$(gettext "Fornecedores")"
	declare -g Realizar_Venda_Saida="$(gettext "Realizar Venda/Saída")"
	declare -g Entradas_de_Produtos="$(gettext "Entradas de Produtos")"
	declare -g Pesquisa_Relatorio_Consulta="$(gettext "Pesquisa/Relatórios/Consulta")"
	declare -g Manutencao="$(gettext "Manutenção")"
	declare -g Configuracao="$(gettext "Configuração")"
	declare -g Sair="$(gettext "Sair")"
	declare -g Sair_do_Sistema="$(gettext "Sair do Sistema")"
	declare -g Opcao_invalida="$(gettext "Opção inválida. Tente novamente.")"
	declare -g Cadastrar="$(gettext 'Cadastrar')"
	declare -g Inclusao="$(gettext 'Inclusão')"
	declare -g Alterar="$(gettext 'Alterar')"
	declare -g Alteracao="$(gettext 'Alteração')"
	declare -g Remover_Excluir="$(gettext 'Remover/Excluir')"
	declare -g Remocao="$(gettext 'Remoção')"
	declare -g Exclusao="$(gettext 'Exclusão')"
	declare -g Pesquisar="$(gettext 'Pesquisar')"
	declare -g Consulta="$(gettext 'Consulta')"
	declare -g Voltar="$(gettext 'Voltar')"
	declare -g Registro_efetuado_com_sucesso="$(gettext "Registro efetuado com sucesso!")"
	declare -g Registro_removido_com_sucesso="$(gettext "Registro removido com sucesso!")"
	declare -g Erro_na_remocao_do_registro="$(gettext "Erro na remoção do registro!")"
	declare -g Erro_no_cadastro_atualizacao_do_registro="$(gettext "Erro no cadastro/atualização do registro")"
	declare -g Formato_de_data_invalida="$(gettext "Formato de data inicial inválida")"
	declare -g Sobre="$(gettext "Sobre")"
	declare -g Sobre_o="$(gettext "Sobre o")"
	declare -g Consultas="$(gettext "Consultas")"
	declare -g Movimento="$(gettext "Movimento")"
	declare -g Relatorios="$(gettext "Relatórios")"
	declare -g Relatorio_de="$(gettext "Relatório de")"
	declare -g Produtos_abaixo_estoque_minimo="$(gettext 'Produtos abaixo estoque minímo')"
	declare -g Produtos_fora_da_validade="$(gettext 'Produtos fora da validade')"
	declare -g Vendas_Diarias="$(gettext 'Vendas Diárias')"
	declare -g Produtos_Vendidos="$(gettext 'Produtos Vendidos')"
	declare -g Atualizar_Estoque="$(gettext 'Atualizar Estoque (conciliação)')"
	declare -g Popular_Databases="$(gettext 'Popular DataBases para testes')"
	declare -g Zerar_Limpar_Produtos="$(gettext 'Zerar/Limpar DataBase Produtos')"
	declare -g Zerar_Limpar_Fornecedor="$(gettext 'Zerar/Limpar DataBase Fornecedor')"
	declare -g Zerar_Limpar_Vendas="$(gettext 'Zerar/Limpar DataBase Vendas')"
	declare -g Zerar_Limpar_Compras="$(gettext 'Zerar/Limpar DataBase Compras')"
	declare -g Dados_Empresa="$(gettext 'Dados Empresa')"
	declare -g Aparencia="$(gettext 'Aparência')"
	declare -g Pano_de_fundo="$(gettext 'Pano de fundo')"
	declare -gi pselecionadoV=1
	declare -gi pselecionadoH=1
}

function sh_environment() {
	local result
	local -a aempresa=('razao' 'ende' 'cida' 'uf' 'cnpj')
	local -a acores=('cabecalho' 'logo' 'statussup' 'statusinf' 'box' 'boxtitle' 'dispbox' 'msgok' 'msgerror' 'conf' 'panofundo' 'corpanofundo')
	local i
	declare -gA Acores=(
		[cabecalho]="$roxo"
		[logo]="$red"
		[statussup]="$ciano"
		[statusinf]="$azul"
		[box]="$azul"
		[boxtitle]="${reverse}$azul"
		[dispbox]="$cinza"
		[msgok]="$green"
		[msgerror]="$red"
		[conf]="$red"
		[panofundo]="█▓░▒pdvShell█▒▓░"
		[corpanofundo]="$cinza"
	)

	if [[ -e "$INI_FILE" ]]; then
		for i in ${aempresa[@]}; do
			result=
			if result="$(TIni.Get "$INI_FILE" "empresa" "$i")" && [[ -n "$result" ]]; then Aempresa["$i"]="$result"; fi
		done

		for i in ${acores[@]}; do
			result=
			if result="$(TIni.Get "$INI_FILE" "cores" "$i")" && [[ -n "$result" ]]; then Acores["$i"]="$result"; fi
		done
	fi
	unset result aempresa acores i
}

# Gera a sequência ANSI de cor de texto (equivalente a "tput setaf N"),
# sem disparar processo externo. Testado contra o tput real para as 256
# cores possíveis (0-255), sem nenhuma divergência.
function ansi_setaf() {
	local n="$1"
	if ((n < 8)); then
		printf "\e[3%dm" "$n"
	elif ((n < 16)); then
		printf "\e[9%dm" "$((n - 8))"
	else
		printf "\e[38;5;%dm" "$n"
	fi
}

# Gera a sequência ANSI de cor de fundo (equivalente a "tput setab N"),
# sem disparar processo externo. Mesma validação de ansi_setaf().
function ansi_setab() {
	local n="$1"
	if ((n < 8)); then
		printf "\e[4%dm" "$n"
	elif ((n < 16)); then
		printf "\e[10%dm" "$((n - 8))"
	else
		printf "\e[48;5;%dm" "$n"
	fi
}

# Extrai o número da cor (0-255) de uma sequência ANSI já montada (mesmo
# que composta com outros códigos como bold/reverse). Usada para descobrir
# em qual cor a tela de seleção deve começar, a partir do valor atual em
# Acores[$ctype]. Devolve vazio se não conseguir identificar.
function ansi_extrair_cor() {
	local seq="$1"
	local n=""
	if [[ "$seq" =~ \[[34]8\;5\;([0-9]+)m ]]; then
		n="${BASH_REMATCH[1]}"
	elif [[ "$seq" =~ \[3([0-7])m ]]; then
		n="${BASH_REMATCH[1]}"
	elif [[ "$seq" =~ \[4([0-7])m ]]; then
		n="${BASH_REMATCH[1]}"
	elif [[ "$seq" =~ \[9([0-7])m ]]; then
		n=$((BASH_REMATCH[1] + 8))
	elif [[ "$seq" =~ \[10([0-7])m ]]; then
		n=$((BASH_REMATCH[1] + 8))
	fi
	echo "$n"
}

function sh_setvarcolors() {
	# does the terminal support true-color?
	if [[ -n "$(command -v "tput")" ]]; then
		#tput setaf 127 | cat -v  #capturar saida
		reset=$'\e(B\e[m'
		rst=$'\e(B\e[m'
		bold=$'\e[1m'
		underline=$'\e[4m'
		nounderline=$'\e[24m'
		reverse=$'\e[7m'

		black=$bold$(ansi_setaf 0)
		red=$bold$(ansi_setaf 196)
		green=$bold$(ansi_setaf 2)
		yellow=$bold$(ansi_setaf 3)
		#		blue=$(ansi_setaf 4)
		blue=$(ansi_setaf 27)
		magenta=$(ansi_setaf 5)
		cyan=$(ansi_setaf 6)
		white=$(ansi_setaf 7)
		gray=$(ansi_setaf 8)
		light_red=$(ansi_setaf 9)
		light_green=$(ansi_setaf 10)
		light_yellow=$(ansi_setaf 11)
		light_blue=$(ansi_setaf 12)
		light_magenta=$(ansi_setaf 13)
		light_cyan=$(ansi_setaf 14)
		light_white=$(ansi_setaf 15)
		orange=$(ansi_setaf 202)
		purple=$(ansi_setaf 125)
		violet=$(ansi_setaf 61)

		# Definir cores de fundo
		preto=$(ansi_setab 0)
		vermelho=$(ansi_setab 196)
		verde=$(ansi_setab 2)
		amarelo=$(ansi_setab 3)
		azul=$(ansi_setab 20)
		roxo=$(ansi_setab 5)
		ciano=$(ansi_setab 6)
		branca="${black}$(ansi_setab 7)"
		cinza=$(ansi_setab 8)
		laranja=$(ansi_setab 202)
		roxa=$(ansi_setab 125)
		violeta=$(ansi_setab 61)
	else
		sh_unsetvarcolors
	fi
}

function sh_unsetvarcolors() {
	unset reset rst bold underline nounderline reverse
	unset black red green yellow blue magenta cyan white gray orange purple violet
	unset light_red light_green light_yellow light_blue light_magenta light_cyan light_white
	unset preto vermelho verde amarelo azul roxo ciano branca cinza laranja roxa violeta
}

function detect_distro() {
	local id=""

	if [[ -r /etc/os-release ]]; then
		# Lê ID=void|arch|debian|... exatamente como a distro declara
		id=$(grep -E '^ID=' /etc/os-release | cut -d= -f2 | tr -d '"')
	elif [[ -r /usr/lib/os-release ]]; then
		id=$(grep -E '^ID=' /usr/lib/os-release | cut -d= -f2 | tr -d '"')
	else
		echo "unknown"
		return
	fi
	echo "$id"
}

function cmd_sudo() {
	if [[ $EUID -eq 0 ]]; then
		"$@"
	else
		sudo "$@"
	fi
}

function sh_setup_Packages() {
	local packagesToInstall="${PACKAGEDEP[@]}"
	local DISTRO=$(detect_distro)

	case "$DISTRO" in
	void)
		msg_info "Instalando necessários pacotes para VOID"
		cmd_sudo xbps-install -Sy "${PACKAGEDEP[@]}" 1>/dev/null
		return "$?"
		;;
	chili | chililinux | arch | manjaro | biglinux)
		msg_info "Instalando necessários pacotes para ${DISTRO^^}VOID"
		sudo pacman -Sy --needed --quiet --noconfirm "${PACKAGEDEP[@]}" 1>/dev/null
		return "$?"
		;;
	*)
		return 1
		;;
	esac
}

function sh_checkDependencies() {
	local d
	local errorFound=false
	declare -a missing

	for d in "${DEPENDENCIES[@]}"; do
		if ! command -v "$d" &>/dev/null; then
			info_msg "${red}Erro${rst}: Não foi possível encontrar o comando ${cyan}'$d'${rst} -> instalar o pacote ${cyan}${PACKAGEDEP[$d]}${rst}"
			missing+=("$d")
			errorFound=true
		fi
	done

	if $errorFound; then
		echo "${yellow}-----------------IMPOSSÍVEL CONTINUAR---------------${rst}"
		echo "Este script precisa dos comandos listados acima"
		echo "Instale-os e/ou verifique se eles estão em seu ${red}\$PATH${rst}"
		echo "${yellow}-----------------IMPOSSÍVEL CONTINUAR---------------${rst}"
		if conf "Deseja instalar os pacotes necessários ?"; then
			sh_setup_Packages
			sh_checkDependencies #overload
		else
			die "Encerrando..."
		fi
	fi
}

# Função para verificar se um valor em uma seção corresponde a um valor de referência em um arquivo INI
# TIni.ExistValue "config.ini" "flatpak" "active" '0'; echo $?
function TIni.ExistValue {
	local config_file="$1"
	local section="$2"
	local key="$3"
	local comp_value="$4"

	if [[ -f "$config_file" ]]; then
		local section_found=false
		local key_found=false
		local value=""
		local line

		while IFS= read -r line; do
			if [[ "$line" == "[$section]" ]]; then
				section_found=true
			elif [[ "$line" == "["* ]]; then
				section_found=false
			fi

			if [[ "$section_found" == true && "$line" == "$key="* ]]; then
				value=$(echo "$line" | cut -d'=' -f2)
				key_found=true
			fi

			if [[ "$section_found" == true && "$key_found" == true ]]; then
				if [[ "$value" == "$comp_value" ]]; then
					return 0 # Valor encontrado e corresponde ao valor de referência
				else
					return 1 # Valor encontrado, mas não corresponde ao valor de referência
				fi
			fi
		done <"$config_file"
	fi
	return 2 # Seção ou chave não encontrada no arquivo INI
}
export -f TIni.ExistValue

# Função para ler um valor do arquivo INI
# TIni.ReadValue "config.ini" "flatpak" "active"
function TIni.ReadValue() {
	local config_file="$1"
	local section="$2"
	local key="$3"
	local found_section=false
	local line

	# Variável para armazenar o valor encontrado
	local value=""

	# Use grep para encontrar a chave na seção especificada no arquivo INI
	while IFS= read -r line; do
		if [[ "$line" =~ ^\[$section\] ]]; then
			found_section=true
		elif [[ "$found_section" == true && "$line" =~ ^$key= ]]; then
			# Encontramos a chave dentro da seção
			value=$(echo "$line" | cut -d'=' -f2)
			break # Saia do loop, pois encontramos o valor
		elif [[ "$line" =~ ^\[.*\] ]]; then
			# Se encontrarmos outra seção, saia do loop para evitar procurar em outras seções
			found_section=false
		fi
	done <"$config_file"

	# Verifique se encontramos o valor
	if [[ -n "$value" ]]; then
		echo "$value"
		return 0
	fi
	return 1
}
export -f TIni.ReadValue

function TIni.Get() {
	local config_file="$1"
	local section="$2"
	local key="$3"
	local line in_section=false value=""

	[[ -f "$config_file" ]] || return 1

	while IFS= read -r line; do
		if [[ "$line" == "[$section]" ]]; then
			in_section=true
			continue
		elif [[ "$line" == \[*\] ]]; then
			in_section=false
			continue
		fi

		if $in_section && [[ "$line" =~ ^[[:space:]]*${key}[[:space:]]*= ]]; then
			value="${line#*=}"
			[[ "$value" =~ ^[[:space:]]*(.*)$ ]] && value="${BASH_REMATCH[1]}"
			break
		fi
	done <"$config_file"

	if [[ -n "$value" ]]; then
		echo "$value"
		return 0
	fi
	return 1
}
export -f TIni.Get

# Exemplo de uso: TIni.Set arquivo.ini snap vilmar 5.7
function TIni.Set() {
	local config_file="$1"
	local section="$2"
	local key="$3"
	local value="$4"
	local found_section=0
	local line

	if [ ! -f "$config_file" ]; then
		# Se não existir, crie o arquivo com a seção, chave e valor fornecidos
		{
			echo "[$section]"
			echo "$key=$value"
		} >>"$config_file"
		return
	fi

	while IFS= read -r line; do
		if [[ "$line" =~ ^\[$section\] ]]; then
			found_section=1
		elif [[ "$line" =~ ^\[.*\] ]]; then
			# Entrou em OUTRA seção: reseta found_section, senão uma nova
			# chave acabava sendo gravada na última seção do arquivo em
			# vez da seção correta (bug: found_section nunca voltava a 0).
			found_section=0
		elif [[ "$found_section" -eq 1 && "${line}" =~ ^${key}[[:space:]]*=[[:space:]]* ]]; then
			# Se a seção e a chave existem, atualize o valor.
			# Escapa caracteres com significado especial na substituição do
			# sed: \ (escape), & (texto casado) e | (delimitador usado
			# aqui) - sem isso, um valor como "Bar & Mercearia" corrompia
			# a gravação (o & era substituído pelo texto original casado).
			local value_escaped="${value//\\/\\\\}"
			value_escaped="${value_escaped//&/\\&}"
			value_escaped="${value_escaped//|/\\|}"
			sed -i "s|^${key}[[:space:]]*=[[:space:]]*.*|${key}=${value_escaped}|" "$config_file"
			return
		fi
	done <"$config_file"

	# Se a seção não existir, crie-a e adicione a chave e o valor
	if [[ "$found_section" -eq 0 ]]; then
		{
			echo ""
			echo "[$section]"
		} >>"$config_file"
	fi
	echo "$key=$value" >>"$config_file"
}
export -f TIni.Set

function TIni.Sanitize() {
	local ini_file="$1"
	local tempfile1
	local tempfile2

	# Criar arquivos temporários
	tempfile1=$(mktemp)
	tempfile2=$(mktemp)

	# Remover linhas em branco do arquivo original
	sed '/^$/d' "$ini_file" >"$tempfile1"

	# Consolidar seções usando awk e salvar no segundo arquivo temporário
	awk '
  BEGIN {
      section = ""
  }
  {
      if ($0 ~ /^\[.*\]$/) {
          section = $0
      } else if (section != "") {
          sections[section] = sections[section] "\n" $0
      }
  }
  END {
    for (section in sections) {
        print section sections[section] "\n"
    }
  }
  ' "$tempfile1" >"$tempfile2"

	sed '/^\s*$/d' "$tempfile2" >"$ini_file"

	# colocar uma linha em branco entre as sessoes e remover a primeira linha em branco
	sed -i -e '/^\[/s/\[/\n&/' -e '1{/^[[:space:]]*$/d}' "$ini_file"
	sed -i -e '1{/^[[:space:]]*$/d}' "$ini_file"

	# marcar como executável
	chmod +x "$ini_file"

	# Remover arquivos temporários
	rm "$tempfile1" "$tempfile2"
}
export -f TIni.Sanitize

function TIni.Clean() {
	local ini_file="$1"

	sed -i -e '/./,$!d' -e 's/[ \t]*=[ \t]*/=/' "$ini_file"
	# awk -F'=' '{
	#   gsub(/^[ \t]+|[ \t]+$/, "", $1);
	#   gsub(/^[ \t]+|[ \t]+$/, "", $2);
	#   print $1 "=" $2
	# }' "$ini_file" | tee "$ini_file"

}
export -f TIni.Clean

# Se a chave e o valor forem exatamente iguais, a função retorna 0.
# Se a chave for encontrada, mas o valor não for igual, a função retorna 2.
# Se a chave não for encontrada, a função retorna 1.
# Se a chave for encontrada com um ponto e vírgula no início, a função também retorna 2.
function TIni.Exist() {
	local config_file="$1"
	local section="$2"
	local key="$3"
	local value="$4"
	local result=1 # Inicializa como 1, indicando que a chave não foi encontrada

	[[ ! -e "$config_file" ]] && return 2
	result=$(awk -F "=" -v section="$section" -v key="$key" -v value="$value" '
        BEGIN {
            encontrado = 1  # Inicializa como 1, indicando que a chave não foi encontrada
        }
        {
            gsub(/^[ \t]+|[ \t]+$/, "", $1);  # Remova espaços em branco em torno do nome da chave
            if ($0 ~ "^\\[" section "\\]") {   # Verifique se estamos na seção correta
                in_section = 1
            } else if (in_section) {
                if ($1 == key) {  # Se estivermos na seção correta, procure a chave
                    if ($0 ~ /^[[:space:]]*;/) {
                        encontrado = 2  # Chave encontrada com ponto e vírgula no início
                        exit
                    }
                    gsub(/^[ \t]+|[ \t]+$/, "", $2);  # Remova espaços em branco em torno do valor
                    if ($0 !~ /^[[:space:]]*;/) {  # Verifique se não é um comentário
                        if (value == "") {
                            encontrado = 0  # Chave encontrada sem valor especificado
                            exit
                        } else if ($2 == value) {
                            encontrado = 0  # Chave encontrada com o valor correto
                            exit
                        } else {
                            encontrado = 2  # Valor fornecido não é igual ao valor da chave
                            exit
                        }
                    }
                }
            } else if ($0 ~ "^\\[.*\\]") {  # Se encontrarmos outra seção, saia da seção atual
                in_section = 0
            }
        }
        END {
            print encontrado
        }
    ' "$config_file")
	return "$result"
}
export -f TIni.Exist

# Escapa aspas simples (') para uso seguro dentro de literais SQL ('...').
# Regra padrão SQL: cada aspa simples vira duas aspas simples.
# Uso: sql_escape "$valor_do_usuario"
function sql_escape() {
	printf '%s' "${1//\'/\'\'}"
}
export -f sql_escape

function sh_splitarray() {
	local str=("$1")
	local pos="${2:-1}"
	local sep="${3:-'|'}"
	local array

	# Corrigir argumentos se a ordem for invertida ou ausente
	[[ "$pos" == "$sep" ]] && {
		sep="${2:-'|'}"
		pos="${3:-1}"
	}
	IFS="$sep" read -r -a array <<<"$str"
	echo "${array[pos - 1]}"
}

function len_split_str() {
	local anew
	IFS='|' read -r -a anew <<<"$1"
	echo "${#anew[@]}"
}

function padr() {
	local texto=$1
	local COLS=$2
	local char=$3
	if test $# -eq 1; then
		COLS=$(tput cols)
		char='='
	fi
	printf "%*s\n" "$COLS" "$texto" | sed "s/ /$char/g"
}

function padl() {
	local texto=$1
	local COLS=$2
	local char=$3
	if test $# -eq 1; then
		COLS=$(tput cols)
		char='='
	fi
	printf "%-*s\n" $COLS "$texto" | sed "s/ /$char/g"
}

function padc() {
	local texto=$1
	local COLS=$2
	local char=$3
	if test $# -eq 1; then
		COLS=$(tput cols)
		char='='
	fi
	printf "%*s\n" $(((${#texto} + $COLS) / 2)) "$texto" | sed "s/ /$char/g"
}

# Calcula larguras de campo ajustadas à largura disponível do terminal:
# campos flexíveis encolhem (nunca abaixo do mínimo) para caber; campos
# fixos nunca mudam. Se houver espaço de sobra, mantém as larguras ideais
# (não estica além do necessário). Resultado em CALC_LARGURAS_RESULT, na
# mesma sintaxe pipe-separated do Max_field_width.
# Uso: calcular_larguras "5|40|2|5" "0|1|0|0" "$largura_disponivel" [minimo]
function calcular_larguras() {
	local ideais="$1"
	local flex="$2"
	local disponivel="$3"
	local minimo="${4:-6}"
	local -a a_ideais a_flex
	IFS='|' read -r -a a_ideais <<<"$ideais"
	IFS='|' read -r -a a_flex <<<"$flex"
	local n=${#a_ideais[@]}
	local i

	local total_ideal=0
	for i in "${!a_ideais[@]}"; do
		total_ideal=$((total_ideal + a_ideais[i]))
	done
	# soma dos separadores '|' entre campos (n-1) + 2 bordas da caixa
	total_ideal=$((total_ideal + n - 1 + 2))

	if ((total_ideal == disponivel)); then
		CALC_LARGURAS_RESULT="$ideais"
		return 0
	fi

	local -a a_result=("${a_ideais[@]}")

	if ((total_ideal < disponivel)); then
		# sobra espaço: distribui proporcionalmente entre as colunas
		# marcadas como flexíveis, pra ocupar toda a área disponível
		local sobra=$((disponivel - total_ideal))
		local total_flex=0
		for i in "${!a_ideais[@]}"; do
			[[ "${a_flex[i]}" == "1" ]] && total_flex=$((total_flex + a_ideais[i]))
		done

		if ((total_flex > 0)); then
			for i in "${!a_ideais[@]}"; do
				if [[ "${a_flex[i]}" == "1" ]]; then
					local acrescimo=$((sobra * a_ideais[i] / total_flex))
					a_result[i]=$((a_ideais[i] + acrescimo))
				fi
			done
			# ajuste fino: sobra de arredondamento vai pro 1º campo flexível
			local total_atual=0
			for i in "${!a_result[@]}"; do
				total_atual=$((total_atual + a_result[i]))
			done
			total_atual=$((total_atual + n - 1 + 2))
			local resto=$((disponivel - total_atual))
			if ((resto > 0)); then
				for i in "${!a_ideais[@]}"; do
					if [[ "${a_flex[i]}" == "1" ]]; then
						a_result[i]=$((a_result[i] + resto))
						break
					fi
				done
			fi
		fi

		local resultado=""
		for i in "${!a_result[@]}"; do
			[[ -n "$resultado" ]] && resultado+="|"
			resultado+="${a_result[i]}"
		done
		CALC_LARGURAS_RESULT="$resultado"
		return 0
	fi

	# total_ideal > disponivel: não cabe, precisa encolher
	local excesso=$((total_ideal - disponivel))
	local total_flex=0
	for i in "${!a_ideais[@]}"; do
		[[ "${a_flex[i]}" == "1" ]] && total_flex=$((total_flex + a_ideais[i]))
	done

	if ((total_flex > 0)); then
		for i in "${!a_ideais[@]}"; do
			if [[ "${a_flex[i]}" == "1" ]]; then
				local reducao=$((excesso * a_ideais[i] / total_flex))
				local nova=$((a_ideais[i] - reducao))
				((nova < minimo)) && nova=$minimo
				a_result[i]=$nova
			fi
		done
	fi

	# ajuste fino: tira 1 de cada vez do maior campo flexível até bater exato
	local total_atual=0
	for i in "${!a_result[@]}"; do
		total_atual=$((total_atual + a_result[i]))
	done
	total_atual=$((total_atual + n - 1 + 2))

	while ((total_atual > disponivel)); do
		local idx_maior=-1
		local maior_valor=0
		for i in "${!a_ideais[@]}"; do
			if [[ "${a_flex[i]}" == "1" && ${a_result[i]} -gt $minimo && ${a_result[i]} -gt $maior_valor ]]; then
				maior_valor=${a_result[i]}
				idx_maior=$i
			fi
		done
		((idx_maior == -1)) && break
		a_result[idx_maior]=$((a_result[idx_maior] - 1))
		total_atual=$((total_atual - 1))
	done

	local resultado=""
	for i in "${!a_result[@]}"; do
		[[ -n "$resultado" ]] && resultado+="|"
		resultado+="${a_result[i]}"
	done
	CALC_LARGURAS_RESULT="$resultado"
}

# Navegador de tabela estilo Browse()/TBrowse do Clipper/Harbour: mostra
# dados tabulares com scroll vertical (só desenha as linhas visíveis,
# nunca estoura o terminal por maior que seja o conjunto de dados) e
# navegação por setas/PgUp/PgDn/Home/End/Enter/ESC.
#
# Uso: browse_tabela linha coluna altura largura "Título" "Cab|eça|lho" "Larg|uras" nome_array [cor] [cores_colunas]
#   título: aparece centralizado na borda superior da caixa, igual o
#   show_menu()/box() já fazem. Pode ser vazio ("") se não precisar.
#
#   nome_array: nome de um array bash já populado, cada elemento é uma
#   linha de dados pipe-delimited (mesmo número de campos do cabeçalho).
#   Uma linha aceita 3 formatos:
#     N campos (padrão)         : sem cor especial, usa cor da coluna/padrão
#     N+1 campos                : último campo = cor da LINHA inteira
#                                  (ex: "5|Produto X|10|$vermelho")
#     N*2 campos                : segunda metade = cor por CÉLULA, uma
#                                  por coluna desta linha (ex: campo de
#                                  estoque com cor diferente por sinal:
#                                  "5|Produto X|-3|10|||$vermelho||")
#
#   cores_colunas (opcional): define uma cor fixa por COLUNA (aplicada
#   em todas as linhas que não sobrescrevem via cor de linha/célula),
#   mesma sintaxe pipe-delimited das larguras (ex: "|||$cyan||$red"
#   pinta só a 5ª e a última coluna). Campo vazio = cor padrão da caixa.
#
#   Prioridade quando mais de uma coexiste: cor de LINHA sempre vence
#   (destaca a linha inteira sem exceção) > cor de CÉLULA (varia célula
#   a célula dentro da mesma linha) > cor de COLUNA (fixa, igual em
#   todas as linhas) > cor padrão da caixa. A linha atualmente
#   selecionada (em vídeo reverso) sempre usa cor uniforme, ignorando
#   cores de célula/coluna, para não cortar o reverso no meio da linha.
#
# Retorno: 0 = ENTER (BROWSE_SELECIONADO=índice 0-based,
#              BROWSE_LINHA_SELECIONADA=linha de dado escolhida)
#          1 = ESC (cancelado) ou falha de leitura de tecla
#          2 = array vazio (nada a mostrar)
function browse_tabela() {
	local linha="$1" col="$2" altura="$3" largura="$4"
	local titulo_caixa="$5"
	local cabecalho="$6"
	local larguras="$7"
	local -n browse_dados="$8"
	local color="${9:-${Acores[box]}}"
	local cores_colunas="${10:-}"

	local total=${#browse_dados[@]}
	local visiveis=$((altura - 3))
	local topo=0 atual=0
	local -a a_larguras a_cabecalho a_cores_col
	IFS='|' read -r -a a_larguras <<<"$larguras"
	IFS='|' read -r -a a_cabecalho <<<"$cabecalho"
	[[ -n "$cores_colunas" ]] && IFS='|' read -r -a a_cores_col <<<"$cores_colunas"
	local i j idx campo linha_fmt valor cor_campo

	BROWSE_SELECIONADO=""
	BROWSE_LINHA_SELECIONADA=""

	if ((total == 0)); then
		return 2
	fi
	((visiveis < 1)) && visiveis=1

	while true; do
		box "$linha" "$col" "$altura" "$largura" "$titulo_caixa" "$color"

		setpos "$((linha + 1))" "$((col + 1))"
		linha_fmt=""
		for i in "${!a_cabecalho[@]}"; do
			utf8_campo "${a_cabecalho[i]}" "${a_larguras[i]}"
			linha_fmt+="$UTF8_CAMPO_RESULT"
			((i < ${#a_cabecalho[@]} - 1)) && linha_fmt+="|"
		done
		printf "%s%s%s" "${Acores[dispbox]}" "$linha_fmt" "$reset"

		for ((i = 0; i < visiveis; i++)); do
			idx=$((topo + i))
			setpos "$((linha + 2 + i))" "$((col + 1))"
			if ((idx < total)); then
				local -a campos_linha
				# o "|" extra no final evita que o read -a descarte um
				# campo vazio no final da linha (bug conhecido do bash:
				# "a|b|" lê só 2 campos em vez de 3) - sem isso, uma
				# linha N×2 (cor por célula) com a última cor vazia
				# perde um campo e quebra a detecção do formato.
				IFS='|' read -r -a campos_linha <<<"${browse_dados[idx]}|"
				local cor_linha=""
				local -a cores_celula=()
				if ((${#campos_linha[@]} == 2 * ${#a_larguras[@]})); then
					# metade dos campos são cor por CÉLULA (uma por coluna
					# desta linha específica, ex: estoque negativo em
					# vermelho, positivo em ciano - varia célula a célula)
					cores_celula=("${campos_linha[@]:${#a_larguras[@]}}")
					campos_linha=("${campos_linha[@]:0:${#a_larguras[@]}}")
				elif ((${#campos_linha[@]} > ${#a_larguras[@]})); then
					cor_linha="${campos_linha[-1]}"
					unset 'campos_linha[-1]'
				fi

				if ((idx == atual)); then
					# Linha selecionada: sempre uniforme (reverso + cor de
					# linha, sem cor por campo) - um reset no meio do
					# caminho cancelaria o vídeo reverso pro resto da linha.
					linha_fmt=""
					for j in "${!a_larguras[@]}"; do
						utf8_campo "${campos_linha[j]}" "${a_larguras[j]}"
						linha_fmt+="$UTF8_CAMPO_RESULT"
						((j < ${#a_larguras[@]} - 1)) && linha_fmt+="|"
					done
					printf "%s%s%s%s" "$reverse" "$cor_linha" "$linha_fmt" "$reset"
				else
					linha_fmt=""
					for j in "${!a_larguras[@]}"; do
						utf8_campo "${campos_linha[j]}" "${a_larguras[j]}"
						campo="$UTF8_CAMPO_RESULT"
						if [[ -n "$cor_linha" ]]; then
							linha_fmt+="$campo"
						else
							cor_campo="${cores_celula[j]:-${a_cores_col[j]:-}}"
							if [[ -n "$cor_campo" ]]; then
								linha_fmt+="${cor_campo}${campo}${reset}"
							else
								linha_fmt+="$campo"
							fi
						fi
						((j < ${#a_larguras[@]} - 1)) && linha_fmt+="|"
					done
					printf "%s%s%s" "$cor_linha" "$linha_fmt" "$reset"
				fi
			fi
		done

		read_key || return 1
		case "$LAST_KEY" in
		"$K_UP")
			if ((atual > 0)); then
				((atual--))
				((atual < topo)) && ((topo--))
			fi
			;;
		"$K_DOWN")
			if ((atual < total - 1)); then
				((atual++))
				((atual >= topo + visiveis)) && ((topo++))
			fi
			;;
		"$K_PGUP")
			atual=$((atual - visiveis))
			((atual < 0)) && atual=0
			topo=$atual
			;;
		"$K_PGDN")
			atual=$((atual + visiveis))
			((atual >= total)) && atual=$((total - 1))
			topo=$((atual - visiveis + 1))
			((topo < 0)) && topo=0
			;;
		"$K_HOME")
			atual=0
			topo=0
			;;
		"$K_END")
			atual=$((total - 1))
			topo=$((total - visiveis))
			((topo < 0)) && topo=0
			;;
		"$K_ENTER")
			BROWSE_SELECIONADO=$atual
			BROWSE_LINHA_SELECIONADA="${browse_dados[atual]}"
			return 0
			;;
		"$K_ESC")
			return 1
			;;
		esac
	done
}

# dispbox "0|0|6" "ID|DESCRICAO DO PRODUTO|ESTOQUE|PREÇO" "5|40|5|11" "$cinza" 'left'
function dispbox() {
	local -A Aarray
	Aarray[coord]="$1"
	Aarray[cabec]="$2"
	Aarray[len]="$3"
	local color="$4"
	local align="$5"

	local aCoord="${Aarray[coord]}"
	local aCabec="${Aarray[cabec]}"
	local aLen="${Aarray[len]}"

	local linha="$(sh_splitarray "$aCoord" 1)"
	local col="$(sh_splitarray "$aCoord" 2)"
	local altura="$(sh_splitarray "$aCoord" 3)"

	local cprintf=
	local nmaxlen=0
	local str
	local lenstr
	local max_width
	local nlen="$(len_split_str "${aCabec[@]}")"

	local frame_top
	local frame_bottom
	local line

	[[ -n "$align" && ($align != 'right' && $align != 'left') ]] && align='right'
	[[ -z "$align" ]] && align='right'

	# Função para alinhar à esquerda
	function dispbox::align_left() {
		local field_width="$1"
		local str="$2"
		local i="$3"
		local nlen="$4"
		local str_width=${#str}
		local sep='|'

		if [[ "$i" -eq "$nlen" ]]; then
			sep=''
		fi
		if ((str_width < field_width)); then
			local extra_space=$((field_width - str_width))
			printf "%s%*s${sep}\n" "$str" "$extra_space" " "
		else
			printf "%s${sep}\n" "$str"
		fi
	}

	# Função para alinhar à direita
	function dispbox::align_right() {
		local field_width="$1"
		local str="$2"
		local i="$3"
		local nlen="$4"
		local str_width=${#str}
		local sep='|'

		if [[ "$i" -eq "$nlen" ]]; then
			sep=''
		fi

		if ((str_width < field_width)); then
			local extra_space=$((field_width - str_width))
			printf "%*s%*s${sep}\n" "$extra_space" " " "$str_width" "$str"
		else
			printf "%*s${sep}\n" "$str_width" "$str"
		fi
	}

	function dispbox::calculate_field_width() {
		local field="$1"
		local max_width="$2"
		local field_width="${#field}"

		if ((field_width > max_width)); then
			echo "$field_width"
		else
			echo "$max_width"
		fi
	}

	for ((i = 1; i <= nlen; i++)); do
		str="$(sh_splitarray "$aCabec" $i)"
		max_width="$(sh_splitarray "$aLen" $i)"
		field_width=$(dispbox::calculate_field_width "$str" "$max_width")
		if [[ "$align" = 'left' ]]; then
			cprintf+="$(dispbox::align_left "${field_width}" "$str" "$i" "$nlen")"
		else
			cprintf+="$(dispbox::align_right "${field_width}" "$str" "$i" "$nlen")"
		fi
		nmaxlen=$((nmaxlen + field_width + 1))
	done

	function dispbox::print_box() {
		# Constrói as linhas superior e inferior do quadro
		frame_top="┌$(printf '─%.0s' $(seq 1 $((nmaxlen - 1))))┐"
		frame_bottom="└$(printf '─%.0s' $(seq 1 $((nmaxlen - 1))))┘"

		# Constrói uma única linha com espaços
		line="│$(printf ' %.0s' $(seq 1 $((nmaxlen - 1))))│"

		# Imprime o quadro com base nas coordenadas, largura e altura
		for ((i = 0; i < altura; i++)); do
			setpos $((linha + i)) "$col"
			if [ $i -eq 0 ]; then
				echo "$frame_top"
				# Imprime o conteúdo centralizado
				setpos "$linha" "$((col + 1))"
				((--nmaxlen))
				printf "$color%-${nmaxlen}s${reset}" "$cprintf"
			elif [ $i -eq $((altura - 1)) ]; then
				echo "$frame_bottom"
			else
				echo "$line"
			fi
		done
	}

	#	printf "%s" "${Acores[box]}"
	#	dispbox::print_box
	box "$linha" "$col" "$altura" "$((nmaxlen + 2))" "$cprintf" "${Acores[box]}"
	#	tput sgr0
}

# Converte formato data yyyy-mm-dd para dd-mm-yyyy
function convert_date_to_ptBR() {
	local cdata="$1"
	date -d "$cdata" +"%d-%m-%Y"
}

# Converte formato data dd-mm-yyyy para yyyy-mm-dd
function convert_date_to_US() {
	local data_in=$1
	local data_out
	local data_parts
	IFS='-' read -r -a data_parts <<<"$data_in"
	data_out="${data_parts[2]}-${data_parts[1]}-${data_parts[0]}"
	echo "$data_out"
}

# Função para validar uma data no formato "dd-mm-yyyy"
# Retorna 0 se a data for válida, e 1 se inválida
function validar_data() {
	local data=$1
	local dia
	local mes
	local ano
	local data_parts
	local bissexto

	IFS='-' read -r -a data_parts <<<"$data"
	if [[ ${#data_parts[@]} -ne 3 ]]; then
		return 1 # Formato inválido
	fi

	dia=${data_parts[0]}
	mes=${data_parts[1]}
	ano=${data_parts[2]}

	# Cada parte precisa ser só dígitos (evita erro de sintaxe em ((...)) com lixo)
	if [[ ! "$dia" =~ ^[0-9]+$ || ! "$mes" =~ ^[0-9]+$ || ! "$ano" =~ ^[0-9]+$ ]]; then
		return 1
	fi

	# Verifica o ano (usa a string original, antes de remover zeros à esquerda)
	if [[ "${#ano}" -lt 4 ]]; then
		return 1
	fi

	# Remove zeros à esquerda: sem isso, "08"/"09" em ((...)) seriam
	# interpretados como octal (base 8), que não tem os dígitos 8 e 9,
	# e o bash quebraria com "valor muito grande para esta base de numeração"
	dia=$((10#$dia))
	mes=$((10#$mes))
	ano=$((10#$ano))

	# Verifica se o ano é bissexto
	if ((ano % 4 == 0 && ano % 100 != 0)) || ((ano % 400 == 0)); then
		bissexto=true
	else
		bissexto=false
	fi

	# Verifica se o mês é válido
	if ((mes < 1 || mes > 12)); then
		return 1
	fi

	# Verifica os dias para meses com 31 dias
	if ((mes == 1 || mes == 3 || mes == 5 || mes == 7 || mes == 8 || mes == 10 || mes == 12)); then
		if ((dia < 1 || dia > 31)); then
			return 1
		fi
	fi

	# Verifica os dias para fevereiro
	if ((mes == 2)); then
		if ((bissexto && (dia < 1 || dia > 29))) || ((!bissexto && (dia < 1 || dia > 28))); then
			return 1
		fi
	fi

	# Verifica os dias para meses com 30 dias
	if ((mes == 4 || mes == 6 || mes == 9 || mes == 11)); then
		if ((dia < 1 || dia > 30)); then
			return 1
		fi
	fi

	return 0 # Data válida
}

# Valida CPF (11 dígitos) ou CNPJ (14 dígitos), aceitando entrada com ou sem
# máscara (pontos, barra, hífen). Confere os dígitos verificadores oficiais
# e rejeita sequências com todos os dígitos iguais (ex: 111.111.111-11).
# Retorna 0 se válido, 1 se inválido.
function validar_cnpj_cpf() {
	local entrada="$1"
	local digitos
	local i peso soma resto dv1 dv2
	local -a nums
	local primeiro repetido

	digitos="${entrada//[^0-9]/}"

	if [[ -n "$digitos" ]]; then
		primeiro="${digitos:0:1}"
		repetido="$(replicate "$primeiro" "${#digitos}")"
		[[ "$digitos" == "$repetido" ]] && return 1
	fi

	case "${#digitos}" in
	11) # CPF
		for ((i = 0; i < 11; i++)); do nums[i]="${digitos:i:1}"; done

		soma=0
		peso=10
		for ((i = 0; i < 9; i++)); do
			soma=$((soma + nums[i] * peso))
			((peso--))
		done
		resto=$((soma % 11))
		dv1=$((resto < 2 ? 0 : 11 - resto))

		soma=0
		peso=11
		for ((i = 0; i < 10; i++)); do
			soma=$((soma + nums[i] * peso))
			((peso--))
		done
		resto=$((soma % 11))
		dv2=$((resto < 2 ? 0 : 11 - resto))

		[[ "$dv1" -eq "${nums[9]}" && "$dv2" -eq "${nums[10]}" ]]
		return $?
		;;
	14) # CNPJ
		for ((i = 0; i < 14; i++)); do nums[i]="${digitos:i:1}"; done

		local -a pesos1=(5 4 3 2 9 8 7 6 5 4 3 2)
		soma=0
		for ((i = 0; i < 12; i++)); do
			soma=$((soma + nums[i] * pesos1[i]))
		done
		resto=$((soma % 11))
		dv1=$((resto < 2 ? 0 : 11 - resto))

		local -a pesos2=(6 5 4 3 2 9 8 7 6 5 4 3 2)
		soma=0
		for ((i = 0; i < 13; i++)); do
			soma=$((soma + nums[i] * pesos2[i]))
		done
		resto=$((soma % 11))
		dv2=$((resto < 2 ? 0 : 11 - resto))

		[[ "$dv1" -eq "${nums[12]}" && "$dv2" -eq "${nums[13]}" ]]
		return $?
		;;
	*)
		return 1
		;;
	esac
}

# Formata CPF/CNPJ (já validados) no padrão oficial:
# CNPJ -> 00.000.000/0000-00 | CPF -> 000.000.000-00
# Aceita entrada com ou sem máscara. Se não tiver 11 ou 14 dígitos, devolve
# a entrada original sem alterar (chamador deve validar antes com validar_cnpj_cpf).
function formatar_cnpj_cpf() {
	local digitos="${1//[^0-9]/}"
	case "${#digitos}" in
	11)
		printf '%s.%s.%s-%s' "${digitos:0:3}" "${digitos:3:3}" "${digitos:6:3}" "${digitos:9:2}"
		;;
	14)
		printf '%s.%s.%s/%s-%s' "${digitos:0:2}" "${digitos:2:3}" "${digitos:5:3}" "${digitos:8:4}" "${digitos:12:2}"
		;;
	*)
		printf '%s' "$1"
		;;
	esac
}

function replicate() {
	local Var
	printf -v Var %"$2"s " "
	echo "${Var// /$1}"
}

function debug() {
	local result
	whiptail \
		--fb \
		--clear \
		--backtitle "[debug]$0" \
		--title "[debug]$0" \
		--yesno "${*}\n" \
		0 40
	result=$?
	if ((result)); then
		exit
	fi
	return $result
}

function die() {
	local msg=$1
	shift
	printf "  %b %s\\n" "${CROSS}" "${bold}${red}${msg}"
	exit 1
}

function info_msg() {
	local retval="${PIPESTATUS[0]}"

	if [[ $retval -eq 0 ]]; then
		printf "  %b %s\\n" "${TICK}" "${*}"
	else
		printf "  %b %s\\n" "${CROSS}" "${*}"
	fi
}

function row() { echo "$Prow"; }
function col() { echo "$Pcol"; }

# Dimensões do terminal em cache: evita disparar 'tput lines'/'tput cols'
# (2 processos cada, por causa do $(...) + tput) toda vez que lastrow()/
# lastcol() são chamadas - e são chamadas MUITAS vezes pelo sistema todo.
# Atualizado uma vez no início e sempre que o terminal for redimensionado.
declare -gi _LASTROW_CACHE_=0
declare -gi _LASTCOL_CACHE_=0

function sh_atualizar_tamanho_tela() {
	_LASTROW_CACHE_=$(tput lines)
	_LASTCOL_CACHE_=$(tput cols)
}
trap 'sh_atualizar_tamanho_tela' WINCH

function lastrow() { echo "$_LASTROW_CACHE_"; }
function lastcol() { echo "$_LASTCOL_CACHE_"; }

function setpos() {
	local row="$1"
	local col="$2"

	Prow="$row"
	Pcol="$col"
	#	tput cup "$row" "$col"
	printf "\e[$((row + 1));$((col + 1))H"
}

function mabox() {
	# Parâmetros da função
	local ntop="$1"
	local nleft="$2"
	local nbottom="$3"
	local nright="$4"
	local color="$5"
	local espacos

	((ntop++))
	((nleft++))
	nbottom=$((ntop + nbottom - 1))

	if [[ -n "$color" ]]; then
		if ((color > 15)); then
			tput setab $color
		else
			tput setaf $color
		fi
	fi

	# Criação da moldura superior, inferior e do meio (sem subshell/fork)
	printf -v espacos '%*s' "$((nright - 2))" ''
	local frame_top="┌${espacos// /─}┐"
	local frame_bottom="└${espacos// /─}┘"
	local frame_middle="│${espacos}│"

	# Desenha a moldura superior
	printf "\e[%s;%sH%s" $ntop $nleft "$frame_top"

	# Desenha os lados do menu (linha do meio já pronta, sem refazer a cada volta)
	for ((i = 1; i <= nbottom - ntop; i++)); do
		printf "\e[$((ntop + i));%sH%s" $nleft "$frame_middle"
	done

	# Desenha a moldura inferior
	printf "\e[$((nbottom));%sH%s" $nleft "$frame_bottom"

	# Move o cursor para a última linha para evitar problemas de exibição
	#    printf "\e[$((nbottom - 1));1H"
}

function sh_fundo() {
	local color="${Acores[corpanofundo]}"
	local frame="${Acores[panofundo]}"
	local lastcol="$_LASTCOL_CACHE_"
	local lastrow="$_LASTROW_CACHE_"
	local buffer
	printf -v buffer '%*s' "$((lastcol * (lastrow - 3) / ${#frame}))" ''
	buffer="${buffer// /$frame}"
	printf "${color}\e[%s;%sH%s" 3 0 "$buffer"
}

function box() {
	local row="$1"
	local col="$2"
	local altura="$3"
	local largura="$4"
	local mensagem="$5"
	local color="$6"
	local color_boxtitle="${Acores[boxtitle]}"
	local tamanho=$((largura - 2))
	local largura_mensagem=${#mensagem}
	local coluna_inicio=$(((largura - largura_mensagem) / 2 + col))

	printf "%s" "$color"
	mabox "$row" "$col" "$altura" "$largura"

	if [[ -n "$mensagem" ]]; then
		setpos "$row" "$((col + 1))"
		printf "$reset$color_boxtitle%-${tamanho}s" " "
		setpos "$row" "$coluna_inicio"
		echo -e "$color_boxtitle$mensagem"
	fi
	printf '\e[0m'
}

read_manual() {
	local result=""
	local char

	while true; do
		# lê um caractere sem eco
		IFS= read -rsn1 char

		case "$char" in
		$'\e') # ESC
			echo "__ESC__"
			return 27
			;;
		$'\n') # ENTER
			echo "$result"
			return 0
			;;
		$'\177') # Backspace
			if [[ -n "$result" ]]; then
				result="${result:0:-1}"
				printf "\b \b"
			fi
			;;
		*)
			result+="$char"
			printf "%s" "$char"
			;;
		esac
	done
}

function get() {
	local row="$1"
	local col="$2"
	local prompt="$3"
	local new_value="$4" # nome da variável de saída
	local old_value="$5" # valor inicial
	local color="${6:-${Acores[box]}}"
	local largura="${7:-0}" # largura máxima a limpar antes de desenhar (0 = não limpa)
	local maxlen="${8:-0}"  # número máximo de caracteres aceitos (0 = sem limite)
	local input="" k
	local cursor=0
	local prev_len=0
	local base_col=$((col + ${#prompt}))

	# valor inicial visível/editável
	input="$old_value"
	cursor=${#input}

	setpos "$row" "$col"
	if ((largura > 0)); then
		printf "%s%s" "$reset" "$color"
		printf "%*s" "$largura" ""
		setpos "$row" "$col"
	fi
	printf "%s%s%s" "$reset" "$color" "$prompt"
	printf "%s%s" "$reverse" "$input"
	prev_len=${#input}
	setpos "$row" "$((base_col + cursor))"

	while true; do
		IFS= read -rsn1 k
		case "$k" in
		$'\e')
			local k2 k3 seq
			IFS= read -rsn1 -t 0.05 k2
			if [[ -z "$k2" ]]; then
				# ESC puro (sem mais bytes) = cancelar
				printf "%s" "$reset"
				return 1
			fi
			seq="$k2"
			if [[ "$k2" == "[" || "$k2" == "O" ]]; then
				while IFS= read -rsn1 -t 0.05 k3; do
					seq+="$k3"
					case "$k3" in
					[0-9] | ';') continue ;; # byte de parâmetro
					*) break ;;               # byte final, sequência completa
					esac
				done
			fi
			case "$seq" in
			"[D") ((cursor > 0)) && ((cursor--)) ;;                        # seta esquerda
			"[C") ((cursor < ${#input})) && ((cursor++)) ;;                # seta direita
			"[H" | "[1~" | "[7~" | "OH") cursor=0 ;;                       # home
			"[F" | "[4~" | "[8~" | "OF") cursor=${#input} ;;               # end
			"[3~")                                                        # delete
				((cursor < ${#input})) && input="${input:0:cursor}${input:cursor+1}"
				;;
			*) : ;; # seta cima/baixo, pgup/pgdn etc. - ignoradas
			esac
			;;
		"" | $'\n' | $'\r')
			printf "%s" "$reset"
			break
			;;
		$'\177' | $'\b')
			if ((cursor > 0)); then
				input="${input:0:cursor-1}${input:cursor}"
				((cursor--))
			fi
			;;
		*)
			if ((maxlen == 0 || ${#input} < maxlen)); then
				input="${input:0:cursor}${k}${input:cursor}"
				((cursor++))
			else
				printf '\a' # beep: limite de caracteres atingido
			fi
			;;
		esac

		# redesenha o campo inteiro (campos são curtos: datas, ids etc.)
		local pad=0
		((prev_len > ${#input})) && pad=$((prev_len - ${#input}))
		setpos "$row" "$base_col"
		printf "%s%s" "$reverse" "$input"
		if ((pad > 0)); then
			printf "%s" "$reset"
			printf "%*s" "$pad" ""
		fi
		prev_len=${#input}
		setpos "$row" "$((base_col + cursor))"
	done

	printf -v "$new_value" '%s' "$input"
	return 0
}

function readconf() {
	local msg="$1"
	local color="${2:-${Acores[conf]}}"
	local nobox="${3:-0}"
	local largura_mensagem
	local nrow="$(row)"
	local ncol="$(col)"

	echo -n -e "$color"
	printf '\a' # beep
	if ((nobox)); then
		setpos "$nrow" "$ncol"
	else
		largura_mensagem=$((${#msg} + 9))
		mabox "$nrow" "$ncol" 3 "$largura_mensagem"
		setpos "$((nrow + 1))" "$((ncol + 1))"
	fi
	if [[ $LC_DEFAULT -eq 0 ]]; then
		read -n1 -s -r -p "$msg [S/n]"
	else
		read -n1 -s -r -p "$msg [Y/n]"
	fi
	echo -n -e "$reset"
	case "${REPLY^}" in
	[SY]) return 0 ;;
	"") return 0 ;;
	*) return 1 ;;
	esac
}

function conf() {
	local msg="$1"
	local color="${2:-${red}}"

	echo -n -e "$color"
	if [[ $LC_DEFAULT -eq 0 ]]; then
		read -r -p "$msg [S/n]"
	else
		read -r -p "$msg [Y/n]"
	fi
	echo -n -e "$reset"
	case "${REPLY^}" in
	[SY]) return 0 ;;
	"") return 0 ;;
	*) return 1 ;;
	esac
}

function readnotconf() {
	local msg="$1"
	local color="${2:-${Acores[conf]}}"
	local nobox="${3:-0}"
	local largura_mensagem
	local nrow="$(row)"
	local ncol="$(col)"

	echo -n -e "$color"
	printf '\a' # beep
	if ((nobox)); then
		setpos "$nrow" "$ncol"
	else
		largura_mensagem=$((${#msg} + 9))
		mabox "$nrow" "$ncol" 3 "$largura_mensagem"
		setpos "$((nrow + 1))" "$((ncol + 1))"
	fi
	if [[ $LC_DEFAULT -eq 0 ]]; then
		read -n1 -s -r -p "$msg [N/s]"
	else
		read -n1 -s -r -p "$msg [N/y]"
	fi
	echo -n -e "$reset"
	case "${REPLY^}" in
	[SY]) return 0 ;;
	*) return 1 ;;
	esac
}

function read_key() {
	local k seq

	IFS= read -rsn1 k || {
		LAST_KEY=""
		return 1
	}

	case "$k" in
	$'\e')
		if IFS= read -rsn1 -t 0.05 seq && [[ $seq == "[" ]]; then
			IFS= read -rsn1 seq
			case "$seq" in
			A) LAST_KEY="$K_UP" ;;
			B) LAST_KEY="$K_DOWN" ;;
			C) LAST_KEY="$K_RIGHT" ;;
			D) LAST_KEY="$K_LEFT" ;;
			H) LAST_KEY="$K_HOME" ;;
			F) LAST_KEY="$K_END" ;;
			5)
				read -rsn1
				LAST_KEY="$K_PGUP"
				;;
			6)
				read -rsn1
				LAST_KEY="$K_PGDN"
				;;
			*) LAST_KEY="$K_ESC" ;;
			esac
		else
			LAST_KEY="$K_ESC"
		fi
		;;
	"")
		LAST_KEY="$K_ENTER"
		;;
	*)
		printf -v LAST_KEY '%d' "'$k"
		;;
	esac
}

function print() {
	local row="$1"
	local col="$2"
	local msg="$3"
	local color="${4:-${Acores[box]}}"

	setpos "$row" "$col"
	printf "${color}${msg}"
}

function yesno() {
	local linha=$1
	local coluna=$2
	local titulo="$3"
	local itens=("$(gettext 'Sim')" "$(gettext 'Não')")
	local tamanho_maximo=${#titulo}
	local quantidade_itens="${#itens[@]}"
	local i tecla selecionado item_formatado
	local sair_do_menu=false
	local color="${Acores[conf]}"
	local item
	local t1 t2
	local altura
	local retorno

	tamanho_maximo=$((tamanho_maximo))
	for item in "${itens[@]}"; do
		((tamanho_maximo = tamanho_maximo < ${#item} ? ${#item} : tamanho_maximo))
	done
	altura=$((quantidade_itens + 4))

	box "$linha" "$coluna" "$altura" "$((tamanho_maximo + 2))" "" "$color"
	print "$((linha + 1))" "$((coluna + 1))" "$titulo" "$color"
	print "$((linha + 2))" "$((coluna))" "├$(replicate "─" "$((tamanho_maximo))")┤" "$color"
	printf '\a' # beep

	while ! $sair_do_menu; do
		for i in "${!itens[@]}"; do
			local item="${itens[i]}"
			local padding=$((tamanho_maximo - ${#item} - 2))
			[[ -n "${aCorItemMenu[i]}" ]] && color="${aCorItemMenu[i]}"
			if [[ $i -eq $selecionado ]]; then
				item_formatado="${reverse}${color}►${item^^}◄%${padding}s${reset}"
			else
				item_formatado="${color} ${item^} %${padding}s${reset}"
			fi
			printf "\e[$((linha + i + 4));%sH${item_formatado}${rst}" "$((coluna + 2))"
		done

		read -rsn1 tecla
		case "$tecla" in
		$'\e')
			# ESC puro ou início de sequência ANSI
			if read -rsn1 -t 0.01 t1 && [[ $t1 == "[" ]]; then
				read -rsn1 t2
				case "$t2" in
				A) ((selecionado = selecionado > 0 ? selecionado - 1 : quantidade_itens - 1)) ;; # ↑
				B) ((selecionado = selecionado < quantidade_itens - 1 ? selecionado + 1 : 0)) ;; # ↓
				C) ((selecionado = selecionado < quantidade_itens - 1 ? selecionado + 1 : 0)) ;; # →
				D) ((selecionado = selecionado > 0 ? selecionado - 1 : quantidade_itens - 1)) ;; # ←
				esac
			else
				retorno=1 # ESC puro
				sair_do_menu=true
			fi
			;;
		"" | $'\n' | $'\r')
			retorno=$((selecionado)) # ENTER → SEMPRE com argumento
			sair_do_menu=true
			;;
		esac
	done

	# Fecha o diálogo repintando as linhas da caixa com o mesmo padrão de
	# fundo do sistema (igual sh_fundo faz para a tela inteira), em vez de
	# apagar para o preto padrão do terminal. Não mexe no resto da tela.
	local cols="$(lastcol)"
	local frame="${Acores[panofundo]}"
	local buffer="$(replicate "$frame" "$((cols * altura / ${#frame} + 1))")"
	tput sgr0
	setpos "$linha" 0
	printf "%s%s" "${Acores[corpanofundo]}" "$buffer"
	tput sgr0
	setpos "$linha" "$coluna"

	return "$retorno"
}

# Caixa de alerta estilo msgbox (dialog --msgbox): moldura, mensagem e um
# único botão [ OK ] centralizados. Diferente do yesno(), não é uma seleção
# Sim/Não - é só um aviso que precisa ser lido e confirmado com Enter, sem
# risco de "vazar" tecla para o campo seguinte (ao contrário de msgerror/
# msgok, que usam uma barra no topo da tela com timeout curto).
function alerta() {
	local linha=$1
	local coluna=$2
	local msg="$3"
	local color="${4:-${Acores[conf]}}"
	local botao="[ $(gettext 'OK') ]"
	local tamanho_maximo=${#msg}
	local tecla
	local padding_msg
	local padding_botao

	((tamanho_maximo = tamanho_maximo < ${#botao} ? ${#botao} : tamanho_maximo))

	box "$linha" "$coluna" 6 "$((tamanho_maximo + 2))" "" "$color"

	padding_msg=$(((tamanho_maximo - ${#msg}) / 2))
	print "$((linha + 1))" "$((coluna + 1 + padding_msg))" "$msg" "$color"

	print "$((linha + 2))" "$coluna" "├$(replicate "─" "$tamanho_maximo")┤" "$color"
	printf '\a' # beep

	padding_botao=$(((tamanho_maximo - ${#botao}) / 2))
	print "$((linha + 4))" "$((coluna + 1 + padding_botao))" "${reverse}${botao}${reset}" "$color"

	while true; do
		read -rsn1 tecla
		case "$tecla" in
		"" | $'\n' | $'\r')
			break
			;;
		esac
	done

	# Fecha o diálogo repintando as linhas da caixa com o mesmo padrão de
	# fundo do sistema (igual sh_fundo faz para a tela inteira), em vez de
	# apagar para o preto padrão do terminal. Não mexe no resto da tela.
	local cols="$(lastcol)"
	local frame="${Acores[panofundo]}"
	local buffer="$(replicate "$frame" "$((cols * 6 / ${#frame} + 1))")"
	tput sgr0
	setpos "$linha" 0
	printf "%s%s" "${Acores[corpanofundo]}" "$buffer"
	tput sgr0
	setpos "$linha" "$coluna"
}

function titulo() {
	local row="$1"
	local mensagem="$2"
	local color="${3:-$black}"
	local extra_left="$4"
	local extra_right="$5"
	local largura_terminal=$_LASTCOL_CACHE_
	local largura_mensagem=${#mensagem}
	local coluna_inicio=$(((largura_terminal - largura_mensagem) / 2))
	local nlen

	printf '\e[s' # Salva a posição atual do cursor
	setpos "$row" 0
	printf "$color%-${largura_terminal}s" ''

	if [[ -n "$extra_left" ]]; then
		setpos "$row" 0
		printf "$bold$white%s" "$extra_left"
	fi

	if [[ -n "$extra_right" ]]; then
		nlen=${#extra_right}
		setpos "$row" $((largura_terminal - nlen))
		printf "$bold$white%s" "$extra_right"
	fi

	setpos "$row" "$coluna_inicio"
	printf "$bold$white%s" "$mensagem"
	printf '\e[0m'
	printf '\e[u'
}

function msgok() {
	local row=1
	local msg="$1"
	local color="${2:-${Acores[msgok]}}"
	local timeout="$3"

	_msg "$row" "$msg" "${Acores[msgok]}" "$timeout"
}

function msgerror() {
	local row=1
	local msg="$1"
	local color="${2:-${Acores[msgerror]}}"
	local timeout="$3"

	_msg "$row" "$msg" "${Acores[msgerror]}" "$timeout"
}

function _msg() {
	local row="$1"
	local msg="$2"
	local color="${3:-$green}"
	local color="$3"
	local timeout="${4:-1}"
	local IsBeep=0

	msg+="$(gettext " Pressione qualquer tecla para continuar")"
	local largura_terminal=$(tput cols)
	local largura_mensagem=${#msg}
	local coluna_inicio=$(((largura_terminal - largura_mensagem) / 2))
	[[ "$color" == "$red" ]] && IsBeep=1

	tput sc
	setpos "$row" 0
	printf "$reverse$color%-${largura_terminal}s" " "
	setpos "$row" "$coluna_inicio"
	((IsBeep)) && printf '\a'
	printf "$reverse$color%s" "$msg"
	((timeout < 0)) && sed -n q </dev/tty
	((timeout > 0)) && pause "$timeout"
	tput sgr0
	setpos "$row" 0
	tput el
	tput rc
}

box_msg() {
  local msg="$1"

  # pega tamanho real do terminal
  local rows cols
  rows=$(tput lines)
  cols=$(tput cols)

  local w=$(( ${#msg} + 4 ))
  local h=3
  local r=$(( (rows - h) / 2 ))
  local c=$(( (cols - w) / 2 ))

  # salva cursor
  tput sc

  # topo
  tput cup "$r" "$c"
  printf "+%s+\n" "$(printf '%*s' $((w-2)) '' | tr ' ' '-')"

  # meio
  tput cup "$((r+1))" "$c"
  printf "| %s |\n" "$msg"

  # fundo
  tput cup "$((r+2))" "$c"
  printf "+%s+\n" "$(printf '%*s' $((w-2)) '' | tr ' ' '-')"

  # restaura cursor
  tput rc
}

function mensagem() {
	local xtitle="${1:-${_SYSTEM_}}"
	local xmsg="${2:-'ERRO'}"
	local timeout="${3:-5}"
	local color="${4:-${red}}"
	local itens=3
	local nrow=$((($(lastrow) - $itens) / 2))
#	local nrow=$((($(lastrow) - $itens) - 1))
#	local nrow=2
	local nleft=15

#  tput smcup   # entra na tela alternativa
   tput civis   # sai e restaura a tela anterior
	titulo 1 "$xtitle" "${Acores[statussup]}"
	box "$nrow" "$nleft" "$itens" "$((lastcol - 30))" "$xtitle" "$white"
	print $((nrow + 1)) $((nleft + 1)) "$(padc "$xmsg" "$((lastcol - 22))" ' ')" "$color"
	inkey "$timeout"
   tput cnorm
#  tput rmcup   # sai e restaura a tela anterior
}

function sh_clear_eol() {
	local coluna_inicial="$1"
	local coluna_final="$2"

	# Posiciona o cursor na coluna_inicial
	echo -en "\033[6;${coluna_inicial}H"

	# Limpa o conteúdo até a coluna_final
	for ((i = coluna_inicial; i <= coluna_final; i++)); do
		setpos $i 0
		tput el
	done

	# Retorna o cursor para a posição inicial
	echo -en "\033[6;${coluna_inicial}H"
}

# Função para obter o próximo número de documento com zeros à esquerda
function obterProximoNumeroDocumento() {
	local tabela="$1"
	local novo_docnr
	novo_docnr=$(sqlite3 "$database" "SELECT printf('%07d', COALESCE(MAX(docnr), 0) + 1) FROM '$tabela';")
	echo "$novo_docnr"
}

function sh_random_docnr() {
	date "+%Y%m%d-%H%M%S"
}

function sh_random_date() {
	local year=$((2000 + RANDOM % 23)) # 2000-2022
	local month=$((1 + RANDOM % 12))   # 1-12
	local max_day

	# Definir o número máximo de dias com base no mês gerado
	case $month in
	4 | 6 | 9 | 11)
		max_day=30
		;;
	2)
		if ((year % 4 == 0 && year % 100 != 0)) || ((year % 400 == 0)); then
			max_day=29
		else
			max_day=28
		fi
		;;
	*)
		max_day=31
		;;
	esac

	local day=$((1 + RANDOM % max_day))
	printf -v RANDOM_DATE_RESULT '%04d-%02d-%02d' "$year" "$month" "$day"
}

function sh_date() {
	date +"%Y-%m-%d"
}

# Multiplica dois valores decimais (ex: quantidade x preço) sem usar bc.
# Assume até 2 casas decimais (padrão de preço do sistema). Resultado em
# DEC_RESULT, formatado com 2 casas decimais.
# Uso: dec_mult "$quantidade" "$valor"; echo "$DEC_RESULT"
function dec_mult() {
	local a="$1" b="$2"
	local a_int a_dec b_int b_dec
	a_int="${a%%.*}"
	if [[ "$a" == *.* ]]; then a_dec="${a#*.}"; else a_dec=0; fi
	b_int="${b%%.*}"
	if [[ "$b" == *.* ]]; then b_dec="${b#*.}"; else b_dec=0; fi
	a_dec="${a_dec}00"
	a_dec="${a_dec:0:2}"
	b_dec="${b_dec}00"
	b_dec="${b_dec:0:2}"
	local a_cents=$((10#$a_int * 100 + 10#$a_dec))
	local b_cents=$((10#$b_int * 100 + 10#$b_dec))
	local result_cents=$((a_cents * b_cents / 100))
	printf -v DEC_RESULT '%d.%02d' $((result_cents / 100)) $((result_cents % 100))
}

# Soma dois valores decimais sem usar bc. Resultado em DEC_RESULT.
# Uso: dec_add "$total" "$subtotal"; total="$DEC_RESULT"
function dec_add() {
	local a="${1:-0}" b="${2:-0}"
	local a_int a_dec b_int b_dec
	a_int="${a%%.*}"
	if [[ "$a" == *.* ]]; then a_dec="${a#*.}"; else a_dec=0; fi
	b_int="${b%%.*}"
	if [[ "$b" == *.* ]]; then b_dec="${b#*.}"; else b_dec=0; fi
	a_dec="${a_dec}00"
	a_dec="${a_dec:0:2}"
	b_dec="${b_dec}00"
	b_dec="${b_dec:0:2}"
	local a_cents=$((10#$a_int * 100 + 10#$a_dec))
	local b_cents=$((10#$b_int * 100 + 10#$b_dec))
	local result_cents=$((a_cents + b_cents))
	printf -v DEC_RESULT '%d.%02d' $((result_cents / 100)) $((result_cents % 100))
}

# Subtrai dois valores decimais sem usar bc (aceita resultado negativo,
# usado para cálculo de troco). Resultado em DEC_RESULT.
# Uso: dec_sub "$efetivo" "$total_venda"; troco="$DEC_RESULT"
function dec_sub() {
	local a="${1:-0}" b="${2:-0}"
	local a_int a_dec b_int b_dec
	a_int="${a%%.*}"
	if [[ "$a" == *.* ]]; then a_dec="${a#*.}"; else a_dec=0; fi
	b_int="${b%%.*}"
	if [[ "$b" == *.* ]]; then b_dec="${b#*.}"; else b_dec=0; fi
	a_dec="${a_dec}00"
	a_dec="${a_dec:0:2}"
	b_dec="${b_dec}00"
	b_dec="${b_dec:0:2}"
	local a_cents=$((10#$a_int * 100 + 10#$a_dec))
	local b_cents=$((10#$b_int * 100 + 10#$b_dec))
	local result_cents=$((a_cents - b_cents))
	local sign=""
	if ((result_cents < 0)); then
		sign="-"
		result_cents=$((-result_cents))
	fi
	printf -v DEC_RESULT '%s%d.%02d' "$sign" $((result_cents / 100)) $((result_cents % 100))
}

# Formata um número (formato ponto, ex: vindo direto do banco) para
# exatamente 2 casas decimais, sem usar %f do printf. O printf %f
# interpreta a entrada de acordo com LC_NUMERIC e pode rejeitar algo
# como "11.3" como "número inválido" em locales com vírgula decimal
# (ex: pt_BR) - e prefixar com LC_NUMERIC=C não resolve de forma
# confiável, porque bash builtins usam o estado de locale já
# carregado do processo, não necessariamente a variável de ambiente
# de um prefixo temporário. Esta função usa só %d (inteiro), que
# nunca depende de locale. Resultado em FORMATAR_2_CASAS_RESULT.
# Uso: formatar_2_casas "$preco"; preco="$FORMATAR_2_CASAS_RESULT"
function formatar_2_casas() {
	local valor="$1"
	local parte_inteira parte_decimal sinal=""
	if [[ "$valor" == -* ]]; then
		sinal="-"
		valor="${valor#-}"
	fi
	if [[ "$valor" == *.* ]]; then
		parte_inteira="${valor%%.*}"
		parte_decimal="${valor#*.}"
	else
		parte_inteira="$valor"
		parte_decimal=""
	fi
	[[ -z "$parte_inteira" ]] && parte_inteira=0
	parte_decimal="${parte_decimal}00"
	parte_decimal="${parte_decimal:0:2}"
	printf -v FORMATAR_2_CASAS_RESULT '%s%d.%02d' "$sinal" "$((10#$parte_inteira))" "$((10#$parte_decimal))"
}

# Arredonda (não trunca) um valor decimal para 2 casas usando bc - para
# quando o valor vem de um SUM() do SQL, que pode ter cauda decimal por
# imprecisão de ponto flutuante (ex: "39.949999999999996") e precisa de
# arredondamento correto, não só corte como formatar_2_casas() faz.
# Corrige as inconsistências do bc: "0" sem decimais e valores menores
# que 1 sem o zero à esquerda (".50" em vez de "0.50"). Assume valor
# não-negativo (uso previsto: somas de vendas). Resultado em
# ARREDONDAR_MOEDA_RESULT.
function arredondar_moeda() {
	local valor="${1:-0}"
	local resultado
	resultado=$(echo "scale=2; ($valor + 0.005) / 1" | bc -l)
	local intpart="${resultado%%.*}"
	local decpart="${resultado#*.}"
	[[ "$resultado" != *.* ]] && decpart=""
	[[ -z "$intpart" ]] && intpart=0
	decpart="${decpart}00"
	decpart="${decpart:0:2}"
	ARREDONDAR_MOEDA_RESULT="${intpart}.${decpart}"
}

# Trunca e preenche uma string até exatamente N caracteres VISUAIS
# (não bytes), sem cortar no meio de um caractere acentuado (Ç, Ã,
# etc). Necessária porque sob locale POSIX/C (sem pt_BR instalada),
# ${#string}/${string:0:N}/printf "%-Ns" contam BYTES, não caracteres -
# um "Ç"/"Ã" ocupa 2 bytes mas só 1 posição visual na tela, causando
# desalinhamento entre o cabeçalho (com acento) e as linhas de dados
# (geralmente sem) nas telas de navegação em tabela. Resultado em
# UTF8_CAMPO_RESULT. Uso: utf8_campo "$valor" "$largura"
function utf8_campo() {
	local valor="$1"
	local largura="$2"
	local -i byte_len=${#valor}
	local -i i=0
	local -i chars=0
	local byte truncado=""
	while ((i < byte_len)); do
		byte="${valor:i:1}"
		if [[ "$byte" != [$'\x80'-$'\xbf'] ]]; then
			((chars >= largura)) && break
			((chars++))
		fi
		truncado+="$byte"
		((i++))
	done
	local stripped="${truncado//[$'\x80'-$'\xbf']/}"
	local -i visivel=${#stripped}
	local -i faltam=$((largura - visivel))
	if ((faltam > 0)); then
		local espacos
		printf -v espacos '%*s' "$faltam" ''
		UTF8_CAMPO_RESULT="${truncado}${espacos}"
	else
		UTF8_CAMPO_RESULT="$truncado"
	fi
}

# END FUNCTIONS

# BEGIN PROCEDURES
function logo() {
	printf "\e[3;0H%s" "${Acores[logo]}"
	figlet "$Mercearia"
	printf "%s" "$reset"
}

function tela() {
	local agora
	printf -v agora '%(%c)T' -1
	sh_fundo
	titulo 0 "$_SYSTEM_" "${Acores[cabecalho]}" "$agora" "$_VERSION_"
	titulo 1 "${Menu_Principal^^}" "${Acores[statussup]}"
#	logo
	titulo "$((_LASTROW_CACHE_ - 1))" "${Aempresa[razao]}" "${Acores[statusinf]}" "$PWD" "$USER"
}

function criar_tabela_produtos() {
	local query

	query="CREATE TABLE IF NOT EXISTS produtos (
        id INTEGER PRIMARY KEY,
        nome VARCHAR(40),
        un VARCHAR(2),
        estoque INTEGER,
        preco REAL,
        codebar VARCHAR(13),
        data DATE,
        validade DATE,
        qmin INTEGER,
        fabricante VARCHAR(5)
    );"
	sqlite3 "$database" "$query"
}

function criar_tabela_vendas() {
	local query
	query="CREATE TABLE IF NOT EXISTS vendas (
        id INTEGER,
        data DATE,
        quantidade INTEGER,
        preco REAL,
        total REAL,
        docnr VARCHAR(7)
    );"
	sqlite3 "$database" "$query"
}

function criar_tabela_compras() {
	local query

	query="CREATE TABLE IF NOT EXISTS compras (
        id INTEGER,
        fornecedor INTEGER,
        data DATE,
        docnr VARCHAR(7),
        quantidade INTEGER,
        custo REAL,
        total REAL,
        validade DATE
    );"
	sqlite3 "$database" "$query"
}

function criar_tabela_fornecedor() {
	local query

	query="CREATE TABLE IF NOT EXISTS fornecedor (
        id INTEGER PRIMARY KEY,
        data DATE,
        nome VARCHAR(40),
        ende VARCHAR(30),
        cida VARCHAR(25),
        uf VARCHAR(2),
        cnpj VARCHAR(18)
    );"
	sqlite3 "$database" "$query"
}

# Retorna a quantidade de registros de uma tabela.
# Uso: dbcount "$database" "fornecedor"
function dbcount() {
	local database="$1"
	local tabela="$2"

	sqlite3 "$database" "SELECT COUNT(*) FROM '$tabela';"
}

function lastrec() {
	local tabela="$1"
	local consulta_sql
	local resultado_info

	consulta_sql="SELECT * FROM '$tabela' ORDER BY id DESC LIMIT 1;"
	resultado_info="$(sqlite3 "$database" "$consulta_sql")"
	echo "$resultado_info"
}

function dbseek() {
	local tabela="$1"
	local campo="$2"
	local search="$3"
	local Header="${4:-0}"
	local Like="${5:-0}"
	local result_info
	local retval=1
	local search_esc

	# $tabela e $campo são sempre valores fixos definidos no código (não vêm do usuário).
	# $search normalmente vem de entrada do usuário (get/identificador/nome) - precisa ser escapado.
	search_esc="$(sql_escape "$search")"

	if ((Like)); then
		if ((Header)); then
			if result_info=$(sqlite3 $database -column -header "SELECT * FROM $tabela WHERE $campo LIKE '%$search_esc%';") && [[ -n "$result_info" ]]; then
				retval=0
			fi
		else
			if result_info=$(sqlite3 $database "SELECT * FROM $tabela WHERE $campo LIKE '%$search_esc%';") && [[ -n "$result_info" ]]; then
				retval=0
			fi
		fi
	else
		if ((Header)); then
			if result_info=$(sqlite3 $database -column -header "SELECT * FROM '$tabela' WHERE $campo='$search_esc';") && [[ -n "$result_info" ]]; then
				retval=0
			fi
		else
   		if result_info=$(sqlite3 $database "SELECT * FROM '$tabela' WHERE $campo='$search_esc';") && [[ -n "$result_info" ]]; then
				retval=0
			fi
		fi
	fi
	echo "$result_info"
	return $retval
}

function produto_inclusao_alteracao() {
	local action="${1:-'I'}"
	local produto_info
	local fornecedor_info
	local last_recno
	local IsHeader=0
	local IsLike=1
	local posmsg=20
	local half_lastcol=$(($(lastcol) / 2))
	local p_id p_nome p_un p_estoque p_preco p_codebar p_data p_validade p_qmin p_fabricante
	local f_id f_data f_nome f_ende f_cida f_uf f_cnpj
	local identificador
	local cdesc
	local xtitle
	local IsInclusao
	local nome un fabricante codebar qmin validade preco
	local query

	if [[ "$action" = 'I' ]]; then
		# I=Inclusao
		cdesc="$(gettext 'Descrição')"
		xtitle="$(gettext 'CADASTRO DE PRODUTO')"
		IsInclusao=1
	else
		# A=Alteracao
		cdesc="$(gettext 'ID/Descrição')"
		xtitle="$(gettext 'ALTERAÇÃO DE PRODUTO')"
		IsInclusao=0
	fi

	while true; do
		while true; do
   		produto_info=
   		last_recno="$(lastrec 'produtos')"
   		tela
   		titulo 1 "$xtitle" "${Acores[statussup]}"
   		box 11 10 9 $half_lastcol "$xtitle" "${Acores[box]}"
   		print 10 11 "$last_recno"

   		if ((IsInclusao)); then
   			print 12 11 "$cdesc            : "
   		else
   			print 12 11 "$cdesc         : "
   		fi
   		print 13 11 "$(gettext "Cod Fabricante")       : "
   		print 14 11 "$(gettext "Código Barras")        : "
   		print 15 11 "$(gettext "Unidade")              : "
   		print 16 11 "$(gettext "Estoque mínimo")       : "
   		print 17 11 "$(gettext "Data validade")        : "
   		print 18 11 "$(gettext "Preço (ex: 4.99 ou 5)"): "

			if ((IsInclusao)); then
				get 12 11 "$cdesc            : " nome || return
				if [[ -z "$nome" ]]; then
					if yesno "$posmsg" 10 "$(gettext "Descrição não pode ser em branco. Cancelar?")"; then
						return
					fi
				fi
            produto_info=$(dbseek 'produtos' 'nome' "$nome" "$IsHeader" "$IsLike")
				if [ -n "$produto_info" ]; then
					# mensagem "${xtitle}" "$(gettext "Descrição já registrada.")"
					alerta "$posmsg" 10 "$(gettext "Descrição já registrada.")" "${Acores[msgerror]}"
					continue
				fi
				break
			else
				get 12 11 "$cdesc         : " nome || return
				if [[ -n "$nome" ]]; then
					if [[ $nome =~ ^[0-9]+$ ]]; then
						IsLike=0
						produto_info=$(dbseek 'produtos' 'id' "$nome" "$IsHeader" "$IsLike")
					else
						IsLike=1
						produto_info=$(dbseek 'produtos' 'nome' "$nome" "$IsHeader" "$IsLike")
					fi
					if [ -n "$produto_info" ]; then
						IFS='|' read -r p_id p_nome p_un p_estoque p_preco p_codebar p_data p_validade p_qmin p_fabricante <<<"$produto_info"
						get 12 11 "$cdesc         : " nome "$p_nome"
						if [[ -z "$nome" ]]; then
							msgerror "$(gettext "Descrição não pode ser em branco.")"
							continue
						fi
					else
						msgerror "$Nenhum_produto_encontrado_nos_parametros_informados" "" 10
						continue
					fi
					break
				else
					if yesno "$posmsg" 10 "$(gettext "Descrição não pode ser em branco. Cancelar?")"; then
						return
					fi
				fi
			fi
		done

		function produto_inclusao_alteracao::desenhar_form() {
			local tecla_residual
			# Descarta qualquer tecla residual antes de redesenhar, evitando que
			# ela vaze para o próximo campo por conta do atraso natural das
			# chamadas de tela()/sqlite3.
			while read -rsn1 -t 0.01 tecla_residual; do :; done

			tela
			titulo 1 "$xtitle" "${Acores[statussup]}"
			box 11 10 9 $half_lastcol "$xtitle" "${Acores[box]}"
			print 10 11 "$last_recno"
			if ((IsInclusao)); then
				print 12 11 "$cdesc            : "
			else
				print 12 11 "$cdesc         : "
			fi
			print 12 40 "${yellow}${nome}${reset}"
			print 13 11 "$(gettext "Cod Fabricante")       : "
			print 14 11 "$(gettext "Código Barras")        : "
			print 15 11 "$(gettext "Unidade")              : "
			print 16 11 "$(gettext "Estoque mínimo")       : "
			print 17 11 "$(gettext "Data validade")        : "
			print 18 11 "$(gettext "Preço (ex: 4.99 ou 5)"): "
		}

		while true; do
			get 13 11 "$(gettext "Cod Fabricante")       : " fabricante "$p_fabricante" || return
			if [[ -n "$fabricante" ]]; then
				if [[ $fabricante =~ ^[0-9]+$ ]]; then
					IsLike=0
					fornecedor_info=$(dbseek 'fornecedor' 'id' "$fabricante" "$IsHeader" "$IsLike")
				else
					IsLike=1
					fornecedor_info=$(dbseek 'fornecedor' 'id' "$fabricante" "$IsHeader" "$IsLike")
				fi
				if [ -n "$fornecedor_info" ]; then
					IFS='|' read -r f_id f_data f_nome f_ende f_cida f_uf f_cnpj <<<"$fornecedor_info"
					print 13 40 "${yellow}${f_nome}"
					break
				else
					if (( "$(dbcount "$database" fornecedor)" )); then
						if yesno "$posmsg" 10 "$(gettext "Fabricante/Fornecedor não encontrado. Deseja escolher da lista de cadastrados?")"; then
							if fornecedor_selecionar; then
								p_fabricante="$FORNECEDOR_SELECIONADO_ID"
							fi
							produto_inclusao_alteracao::desenhar_form
						fi
					else
						if yesno "$posmsg" 10 "$(gettext "Nenhum fornecedor cadastrado. Deseja cadastrar um fornecedor agora?")"; then
							fornecedor_inclusao
							produto_inclusao_alteracao::desenhar_form
						fi
					fi
					continue
				fi
			else
				# Campo em branco: vai direto para a tela de seleção de fornecedores
				if (( "$(dbcount "$database" fornecedor)" )); then
					if fornecedor_selecionar; then
						p_fabricante="$FORNECEDOR_SELECIONADO_ID"
					fi
					produto_inclusao_alteracao::desenhar_form
				else
					if yesno "$posmsg" 10 "$(gettext "Nenhum fornecedor cadastrado. Deseja cadastrar um fornecedor agora?")"; then
						fornecedor_inclusao
						produto_inclusao_alteracao::desenhar_form
					fi
				fi
				continue
			fi
		done

		get 14 11 "$(gettext "Código Barras")        : " codebar "$p_codebar"

		while true; do
			get 15 11 "$(gettext "Unidade")              : " un "$p_un" "${Acores[box]}" 0 2 || return
			un=${un^^}
			if [[ "${#un}" -eq 2 ]]; then
				break
			else
				alerta "$posmsg" 10 "$(gettext "Unidade deve ter exatamente 2 caracteres (ex: KG, UN, PC)")" "${Acores[msgerror]}"
			fi
		done

		get 16 11 "$(gettext "Estoque mínimo")       : " qmin "$p_qmin"

		p_validade="$(convert_date_to_ptBR "$p_validade")"
		while true; do
			get 17 11 "$(gettext "Data validade")        : " validade "$p_validade"
			if [[ -n "$validade" ]]; then
				if validar_data "$validade"; then
					break
				else
					msgerror "$(gettext "Data inválida")"
					continue
				fi
			else
				if yesno "$posmsg" 10 "$(gettext "Data não pode ser em branco. Cancelar?")"; then
					return
				fi
			fi
		done

		# Solicita o preço como número inteiro ou decimal com ponto (ex: 4.99) e verifica se não está em branco
		while true; do
			get 18 11 "$(gettext "Preço (ex: 4.99 ou 5)"): " preco "$p_preco"
			if [[ -n "$preco" ]] && [[ $preco =~ ^[0-9]+(\.[0-9]+)?$ ]]; then
				break
			else
				msgerror "$(gettext "Formato inválido. Usar ponto decimal ex: 4.99 ou número inteiro.")"
			fi
		done
		#		setpos "$posmsg" 10
		if yesno $posmsg 10 "$(gettext "Confirma inclusão/atualização do produto?")"; then
			nome=${nome^^}
			un=${un^^}
			local nome_esc="$(sql_escape "$nome")"
			local un_esc="$(sql_escape "$un")"
			local codebar_esc="$(sql_escape "$codebar")"
			local qmin_esc="$(sql_escape "$qmin")"
			local fabricante_esc="$(sql_escape "$fabricante")"
			query="INSERT OR REPLACE INTO produtos (id, nome, un, preco, codebar, estoque, validade, qmin, fabricante) VALUES (
		        (SELECT id FROM produtos WHERE id='$p_id'), '$nome_esc', '$un_esc', '$preco', '$codebar_esc',
		        (SELECT estoque FROM produtos WHERE id='$p_id'), '$(convert_date_to_US "$validade")', '$qmin_esc', '$fabricante_esc'
		    );"

			if sqlite3 "$database" "$query"; then
				msgok "$Registro_efetuado_com_sucesso"
			else
				msgerror "$Erro_no_cadastro_atualizacao_do_registro"
			fi
		else
			msgerror "$(gettext "Inclusão/alteração não efetuada.")"
		fi
	done
}

function produto_exclusao() {
	local xtitle="$(gettext "EXCLUSÃO DE PRODUTO")"
	local identificador
	local half_lastcol=$(($(lastcol) / 2))
	local posmsg=21
	local produto_info
	local fornecedor_info
	local p_id p_nome p_un p_estoque p_preco p_codebar p_data p_validade p_qmin p_fabricante
	local f_id f_data f_nome f_ende f_cida f_uf f_cnpj

	while true; do
		tela
		titulo 1 "$xtitle" "${Acores[statussup]}"
		box 11 10 10 "$half_lastcol" "$xtitle" "${Acores[box]}"
		print 12 11 "$(gettext "ID/Nome")              : "
		print 13 11 "$(gettext "Descrição")            : "
		print 14 11 "$(gettext "Fabricante")           : "
		print 15 11 "$(gettext "Código Barras")        : "
		print 16 11 "$(gettext "Unidade")              : "
		print 17 11 "$(gettext "Estoque mínimo")       : "
		print 18 11 "$(gettext "Data validade")        : "
		print 19 11 "$(gettext "Preço (ex: 4.99 ou 5)"): "

		get 12 11 "$(gettext "ID/Nome")              : " identificador || return
		identificador=${identificador^^}

		if [[ -z "$identificador" ]]; then
			setpos "$posmsg" 10
			if readconf "$(gettext "O ID não pode ser em branco. Cancelar?")"; then
				return
			fi
		fi

		if [[ $identificador =~ ^[0-9]+$ ]]; then
			produto_info="$(dbseek 'produtos' 'id' "$identificador")"
		else
			produto_info="$(dbseek 'produtos' 'nome' "$identificador")"
		fi

		if [[ -n "$produto_info" ]]; then
			IFS='|' read -r p_id p_nome p_un p_estoque p_preco p_codebar p_data p_validade p_qmin p_fabricante <<<"$produto_info"
			if [[ -n "$p_fabricante" ]]; then
				if fornecedor_info=$(dbseek 'fornecedor' 'id' "$p_fabricante") && [ -n "$fornecedor_info" ]; then
					IFS='|' read -r f_id f_data f_nome f_ende f_cida f_uf f_cnpj <<<"$fornecedor_info"
					print 14 40 "${yellow}$f_nome${reset}"
				fi
			fi

			print 13 34 "${yellow}$p_nome${reset}"
			print 14 34 "${yellow}$p_fabricante${reset}"
			print 15 34 "${yellow}$p_codebar${reset}"
			print 16 34 "${yellow}$p_un${reset}"
			print 17 34 "${yellow}$p_qmin${reset}"
			print 18 34 "${yellow}$(convert_date_to_ptBR "$p_validade")${reset}"
			print 19 34 "${yellow}$p_preco${reset}"

			setpos "$posmsg" 10
			if readnotconf "$(gettext "Confirma exclusão do produto?")"; then
				msgok "$(gettext "Removendo cadastro do produto")" "" 0
				sqlite3 "$database" "DELETE FROM produtos WHERE id = $p_id;"
				setpos "$((posmsg + 1))" 11
				if readconf "$(gettext "Deseja remover registros de vendas e compras desse produto?")"; then
					msgok "$(gettext "Removendo registros de vendas")" "" 0
					sqlite3 "$database" "DELETE FROM vendas WHERE id = $p_id;"
					msgok "$(gettext "Removendo registros de compras")" "" 0
					sqlite3 "$database" "DELETE FROM compras WHERE id = $p_id;"
				fi
				msgok "$Registro_removido_com_sucesso"
			fi
		else
			msgerror "$Nenhum_produto_encontrado_nos_parametros_informados" "" 10
		fi
	done
}

function inkey() {
	local timeout="$1"
	local lastkey
	[[ -z "$timeout" ]] && timeout=-1
	IFS= read -t "$timeout" -n 1 -s lastkey
	[[ -z "$lastkey" ]] && lastkey=""
}

function pause() {
	local timeout="$1"
	local msg="$2"
	#	>/dev/tty printf '%s' "${msg:-Pressione qualquer tecla para continuar...}"
	printf >/dev/tty '%s' "${msg:-""}"
	[[ $ZSH_VERSION ]] && read -krs # Use -u0 to read from STDIN
	[[ $BASH_VERSION ]] && read </dev/tty -t "$timeout" -rsn1
	printf '\n'
}

function pausesed() {
	sed -n q </dev/tty
}

function produto_pesquisa() {
	local produto_info
	local fornecedor_info
	local IsHeader=0
	local IsLike=0
	local id nome un estoque preco codebar data validade qmin fabricante
	local f_id f_data f_nome f_ende f_cida f_uf f_cnpj
	local Max_field_width
	local identificador
	local id_ini id_fim
	local -a linhas_produto

	while true; do
		tela
		titulo 1 "$(gettext "PESQUISAR PRODUTOS")" "${Acores[statussup]}"
		box "$nTop" 0 3 $(($(lastcol) - 1)) "$(gettext "PESQUISAR PRODUTOS")" "${Acores[box]}"
		get $((nTop + 1)) 1 "$(gettext "Pesquisar por: nome, id <x>|<x-y>, f<id> ou *=tudo") : " identificador || return

		[[ -z "$identificador" ]] && return
		[[ "$identificador" == "*" ]] && identificador=

		mensagem "$(gettext "PESQUISAR PRODUTOS")" "$(gettext "Processando...")" 0 "$yellow"

		if [[ $identificador =~ ^[0-9]+$ ]]; then
			IsLike=0
			produto_info=$(dbseek 'produtos' 'id' "$identificador" "$IsHeader" "$IsLike")
		elif [[ $identificador =~ ^[fF]([0-9]+)$ ]]; then
			identificador=${BASH_REMATCH[1]}
			IsLike=0
			produto_info=$(dbseek 'produtos' 'fabricante' "$identificador" "$IsHeader" "$IsLike")
			if fornecedor_info=$(dbseek 'fornecedor' 'id' "$identificador") && [ -n "$fornecedor_info" ]; then
				IFS='|' read -r f_id f_data f_nome f_ende f_cida f_uf f_cnpj <<<"$fornecedor_info"
				print $((nTop + 1)) 61 "${yellow}${f_nome}"
			fi
		elif [[ $identificador =~ ^([0-9]+)-([0-9]+)$ ]]; then
			id_ini=${BASH_REMATCH[1]}
			id_fim=${BASH_REMATCH[2]}
			produto_info=$(sqlite3 $database "SELECT * FROM produtos WHERE id >= $id_ini AND id <= $id_fim;")
		else
			IsLike=1
			produto_info=$(dbseek 'produtos' 'nome' "$identificador" "$IsHeader" "$IsLike")
		fi

		if [[ -z "$produto_info" ]]; then
			msgerror "$Nenhum_produto_encontrado_nos_parametros_informados" "" 10
			continue
		fi

		linhas_produto=()
		while IFS='|' read -r id nome un estoque preco codebar data validade qmin fabricante; do
			formatar_2_casas "$preco"
			preco="$FORMATAR_2_CASAS_RESULT"

			# Cor dinâmica do ESTOQUE: vermelho se < QMIN, amarelo se
			# == QMIN, ciano se > QMIN.
			local cor_estoque=""
			if [[ "$estoque" =~ ^-?[0-9]+$ && "$qmin" =~ ^-?[0-9]+$ ]]; then
				if ((estoque < qmin)); then
					cor_estoque="$red"
				elif ((estoque == qmin)); then
					cor_estoque="$yellow"
				else
					cor_estoque="$cyan"
				fi
			fi

			# Formato N×2 do browse_tabela: 9 campos de dado + 9 campos de
			# cor (mesma ordem das colunas). Só ESTOQ (índice 6) recebe cor;
			# as demais ficam vazias e caem no fallback de cor de coluna.
			local -a cores_linha=("" "" "" "" "" "" "$cor_estoque" "" "")
			local cores_str
			cores_str=$(IFS='|'; echo "${cores_linha[*]}")

			linhas_produto+=("$id|$nome|$un|$fabricante|$(convert_date_to_ptBR "$validade")|$qmin|$estoque|${preco/./,}|$codebar|$cores_str")
		done <<<"$produto_info"

		calcular_larguras "5|40|2|5|10|5|5|10|13" "0|1|0|0|0|0|0|0|0" "$(($(lastcol) - 2))"
		Max_field_width="$CALC_LARGURAS_RESULT"

		browse_tabela "$((nTop + 3))" 0 "$(($(lastrow) - $((nTop + 3))))" "$(($(lastcol) - 1))" "$(gettext "PESQUISAR PRODUTOS")" \
			"ID|DESCRIÇÃO DO PRODUTO|UN|FABRI|VALIDADE|QMIN|ESTOQ|PREÇO|CODEBAR" "$Max_field_width" linhas_produto "${Acores[box]}" \
			"|||||$cyan|$cyan|$yellow"
	done
}

function relatorio_produtos_minimo() {
	local xtitle="${Relatorio_de^^} ${Produtos_abaixo_estoque_minimo^^}"
	local produto_info
	local id nome un estoque preco codebar data validade qmin fabricante
	local identificador
	local fornecedor_info
	local f_id f_data f_nome f_ende f_cida f_uf f_cnpj
	local id_ini id_fim
	local Max_field_width
	local -a linhas_produto
	local cor_linha

	while true; do
		tela
		titulo 1 "$xtitle" "${Acores[statussup]}"
		box "$nTop" 0 3 $(($(lastcol) - 1)) "$xtitle" "${Acores[box]}"
		get $((nTop + 1)) 1 "$(gettext "Pesquisar por: nome, id <x>|<x-y>, f<id> ou *=tudo") : " identificador || return

		[[ -z "$identificador" ]] && return
		[[ "$identificador" == "*" ]] && identificador=

		mensagem "$xtitle" "$(gettext "Processando...")" 0 "$yellow"

		if [[ $identificador =~ ^[0-9]+$ ]]; then
			produto_info=$(sqlite3 $database "SELECT * FROM produtos WHERE id='$identificador';")
		elif [[ $identificador =~ ^[fF]([0-9]+)$ ]]; then
			identificador=${BASH_REMATCH[1]}
			produto_info=$(sqlite3 $database "SELECT * FROM produtos WHERE fabricante = '$identificador' AND produtos.estoque < produtos.qmin;")
			if fornecedor_info=$(dbseek 'fornecedor' 'id' "$identificador") && [ -n "$fornecedor_info" ]; then
				IFS='|' read -r f_id f_data f_nome f_ende f_cida f_uf f_cnpj <<<"$fornecedor_info"
				print $((nTop + 1)) 61 "${yellow}${f_nome}"
			fi
		elif [[ $identificador =~ ^([0-9]+)-([0-9]+)$ ]]; then
			id_ini=${BASH_REMATCH[1]}
			id_fim=${BASH_REMATCH[2]}
			produto_info=$(sqlite3 $database "SELECT * FROM produtos WHERE id >= '$id_ini' AND id <= '$id_fim' AND produtos.estoque < produtos.qmin;")
		else
			local identificador_esc="$(sql_escape "$identificador")"
			produto_info=$(sqlite3 $database "SELECT * FROM produtos WHERE id LIKE '%$identificador_esc%' AND produtos.estoque < produtos.qmin;")
		fi

		if [[ -z "$produto_info" ]]; then
			msgerror "$Nenhum_produto_encontrado_nos_parametros_informados" "" 10
			continue
		fi

		linhas_produto=()
		while IFS='|' read -r id nome un estoque preco codebar data validade qmin fabricante; do
			if [[ $estoque -lt $qmin ]]; then
				cor_linha="$red"
			else
				cor_linha="$green"
			fi
			linhas_produto+=("$id|$(convert_date_to_ptBR "$validade")|$nome|$un|$qmin|$estoque|$cor_linha")
		done <<<"$produto_info"

		calcular_larguras "5|10|40|2|7|7" "0|0|1|0|0|0" "$(($(lastcol) - 2))"
		Max_field_width="$CALC_LARGURAS_RESULT"

		browse_tabela "$((nTop + 3))" 0 "$(($(lastrow) - $((nTop + 3))))" "$(($(lastcol) - 1))" "$xtitle" \
			"ID|VALIDADE|DESCRIÇÃO DO PRODUTO|UN|QMIN|ESTOQUE" "$Max_field_width" linhas_produto "${Acores[box]}"
	done
}

function relatorio_produtos_fora_validade() {
	local xtitle="${Relatorio_de^^} ${Produtos_fora_da_validade^^}"
	local produto_info
	local id nome un estoque preco codebar data validade qmin fabricante
	local identificador
	local fornecedor_info
	local f_id f_data f_nome f_ende f_cida f_uf f_cnpj
	local id_ini id_fim
	local Max_field_width
	local -a linhas_produto

	while true; do
		tela
		titulo 1 "$xtitle" "${Acores[statussup]}"
		box "$nTop" 0 3 $(($(lastcol) - 1)) "$xtitle" "${Acores[box]}"
		get $((nTop + 1)) 1 "$(gettext "Pesquisar por: nome, id <x>|<x-y>, f<id> ou *=tudo") : " identificador || return

		[[ -z "$identificador" ]] && return
		[[ "$identificador" == "*" ]] && identificador=

		mensagem "$xtitle" "$(gettext "Processando...")" 0 "$yellow"

		if [[ $identificador =~ ^[0-9]+$ ]]; then
			produto_info=$(sqlite3 $database "SELECT * FROM produtos WHERE id='$identificador';")
		elif [[ $identificador =~ ^[fF]([0-9]+)$ ]]; then
			identificador=${BASH_REMATCH[1]}
			produto_info=$(sqlite3 $database "SELECT * FROM produtos WHERE fabricante = '$identificador' AND produtos.validade < '$(sh_date)';")
			if fornecedor_info=$(dbseek 'fornecedor' 'id' "$identificador") && [ -n "$fornecedor_info" ]; then
				IFS='|' read -r f_id f_data f_nome f_ende f_cida f_uf f_cnpj <<<"$fornecedor_info"
				print $((nTop + 1)) 61 "${yellow}${f_nome}"
			fi
		elif [[ $identificador =~ ^([0-9]+)-([0-9]+)$ ]]; then
			id_ini=${BASH_REMATCH[1]}
			id_fim=${BASH_REMATCH[2]}
			produto_info=$(sqlite3 $database "SELECT * FROM produtos WHERE id >= '$id_ini' AND id <= '$id_fim' AND produtos.validade < '$(sh_date)';")
		else
			local identificador_esc="$(sql_escape "$identificador")"
			produto_info=$(sqlite3 $database "SELECT * FROM produtos WHERE id LIKE '%$identificador_esc%' AND produtos.validade < '$(sh_date)';")
		fi

		if [[ -z "$produto_info" ]]; then
			msgerror "$Nenhum_produto_encontrado_nos_parametros_informados" "" 10
			continue
		fi

		linhas_produto=()
		while IFS='|' read -r id nome un estoque preco codebar data validade qmin fabricante; do
			# Cor dinâmica do ESTOQUE (mesmo esquema do PESQUISAR PRODUTOS):
			# vermelho se < QMIN, amarelo se == QMIN, ciano se > QMIN.
			local cor_estoque=""
			if [[ "$estoque" =~ ^-?[0-9]+$ && "$qmin" =~ ^-?[0-9]+$ ]]; then
				if ((estoque < qmin)); then
					cor_estoque="$red"
				elif ((estoque == qmin)); then
					cor_estoque="$yellow"
				else
					cor_estoque="$cyan"
				fi
			fi
			# Formato N×2: 6 campos de dado + 6 de cor; só ESTOQUE (índice
			# 5, última coluna) recebe cor.
			local -a cores_linha=("" "" "" "" "" "$cor_estoque")
			local cores_str
			cores_str=$(IFS='|'; echo "${cores_linha[*]}")
			linhas_produto+=("$id|$(convert_date_to_ptBR "$validade")|$nome|$un|$qmin|$estoque|$cores_str")
		done <<<"$produto_info"

		calcular_larguras "5|10|40|2|7|7" "0|0|1|0|0|0" "$(($(lastcol) - 2))"
		Max_field_width="$CALC_LARGURAS_RESULT"

		browse_tabela "$((nTop + 3))" 0 "$(($(lastrow) - $((nTop + 3))))" "$(($(lastcol) - 1))" "$xtitle" \
			"ID|VALIDADE|DESCRIÇÃO DO PRODUTO|UN|QMIN|ESTOQUE" "$Max_field_width" linhas_produto "${Acores[box]}"
	done
}

function fornecedor_inclusao() {
	local xtitle="$(gettext "CADASTRO DE FORNECEDOR")"
	local data_dia="$(sh_date)"
	local fornecedor_info
	local fornecedor_id
	local fornecedor_nome
	local fornecedor_ende
  local fornecedor_data
  local fornecedor_cida
  local fornecedor_esta
  local fornecedor_cnpj
	local last_recno
	local IsHeader=0
	local half_lastcol=$(($(lastcol) / 2))
	local nome ende cida esta cnpj
	local query
	local tecla_residual

	while true; do
		fornecedor_info=
		fornecedor_id=
		fornecedor_data=
		fornecedor_nome=
		fornecedor_ende=
		fornecedor_cida=
		fornecedor_esta=
		fornecedor_cnpj=
		last_recno="$(lastrec 'fornecedor')"

		# Descarta qualquer tecla residual da tela anterior antes de redesenhar,
		# evitando que ela vaze para o primeiro campo (Nome) por conta do
		# atraso natural das chamadas de tela()/sqlite3 acima.
		while read -rsn1 -t 0.01 tecla_residual; do :; done

		tela
		titulo 1 "$xtitle" "${Acores[statussup]}"
		box 11 10 7 "$half_lastcol" "$xtitle" "${Acores[box]}"
		print 10 11 "$last_recno"
		print 12 11 "$(gettext "Nome")                 : "
		print 13 11 "$(gettext "Endereço")             : "
		print 14 11 "$(gettext "Cidade")               : "
		print 15 11 "$(gettext "Estado")               : "
		print 16 11 "$(gettext "CNPJ/CPF")             : "

		while true; do
			get 12 11 "$(gettext "Nome")                 : " nome "" "${Acores[box]}" "$((half_lastcol - 2))" || return
			if [[ -n "$nome" ]]; then
				if fornecedor_info=$(dbseek fornecedor nome "${nome^^}" "$IsHeader" 0) && [ -n "$fornecedor_info" ]; then
					alerta 18 10 "$(gettext "Fornecedor já cadastrado com esse nome")" "${Acores[msgerror]}"
					continue
				fi
				break
			else
				if yesno 18 10 "$(gettext "O nome não pode ser em branco. Cancelar?")"; then
					return
				fi
			fi
		done

		get 13 11 "$(gettext "Endereço")             : " ende "$fornecedor_ende" "${Acores[box]}" "$((half_lastcol - 2))" || return
		get 14 11 "$(gettext "Cidade")               : " cida "$fornecedor_cida" "${Acores[box]}" "$((half_lastcol - 2))" || return
		get 15 11 "$(gettext "Estado")               : " esta "$fornecedor_esta" "${Acores[box]}" "$((half_lastcol - 2))" || return

		while true; do
			get 16 11 "$(gettext "CNPJ/CPF")             : " cnpj "$fornecedor_cnpj" "${Acores[box]}" "$((half_lastcol - 2))" || return
			if [[ -z "$cnpj" ]]; then
				break
			elif validar_cnpj_cpf "$cnpj"; then
				break
			else
				alerta 18 10 "$(gettext "CNPJ/CPF inválido")" "${Acores[msgerror]}"
			fi
		done

		if yesno 18 10 "$(gettext "Confirma inclusão/atualização do fornecedor?")"; then
			nome=${nome^^}
			ende=${ende^^}
			cida=${cida^^}
			esta=${esta^^}
			[[ -n "$cnpj" ]] && cnpj="$(formatar_cnpj_cpf "$cnpj")"
			local nome_esc="$(sql_escape "$nome")"
			local ende_esc="$(sql_escape "$ende")"
			local cida_esc="$(sql_escape "$cida")"
			local esta_esc="$(sql_escape "$esta")"
			local cnpj_esc="$(sql_escape "$cnpj")"
			query="INSERT OR REPLACE INTO fornecedor (id,data, nome, ende, cida, uf, cnpj) VALUES (
		        (SELECT id FROM fornecedor WHERE id='$fornecedor_id'),
				'$data_dia', '$nome_esc', '$ende_esc', '$cida_esc', '$esta_esc', '$cnpj_esc'
			);"

			if sqlite3 "$database" "$query"; then
				alerta 18 10 "$Registro_efetuado_com_sucesso" "${Acores[msgok]}"
			else
				alerta 18 10 "$Erro_no_cadastro_atualizacao_do_registro" "${Acores[msgerror]}"
			fi
		else
			alerta 18 10 "$(gettext "Inclusão/alteração não efetuada.")" "${Acores[msgerror]}"
		fi
	done
}

function fornecedor_alteracao() {
	local xtitle="$(gettext "ALTERAÇÃO DE FORNECEDOR")"
	local data_dia="$(sh_date)"
	local fornecedor_info
  local fornecedor_id
  local fornecedor_data
  local fornecedor_nome
  local fornecedor_ende
  local fornecedor_cida
  local fornecedor_esta
  local fornecedor_cnpj
	local last_recno
	local IsHeader=0
	local IsLike=1
	local identificador
	local nome ende cida esta cnpj
	local query

	while true; do
		fornecedor_info=
		last_recno="$(lastrec 'fornecedor')"
		tela
		titulo 1 "$xtitle" "${Acores[statussup]}"
		box 11 10 8 80 "$xtitle" "${Acores[box]}"
		print 10 11 "$last_recno"
		print 12 11 "$(gettext "ID/Nome")              : "
		print 13 11 "$(gettext "Nome")                 : "
		print 14 11 "$(gettext "Endereço")             : "
		print 15 11 "$(gettext "Cidade")               : "
		print 16 11 "$(gettext "Estado")               : "
		print 17 11 "$(gettext "CNPJ/CPF")             : "

		get 12 11 "$(gettext "ID/Nome")              : " identificador "" "${Acores[box]}" 78 || return

		if [[ -z "$identificador" ]]; then
			if yesno 19 10 "$(gettext "ID/Nome não pode ser em branco. Cancelar?")"; then
				return
			fi
		fi
		if [[ $identificador =~ ^[0-9]+$ ]]; then
			fornecedor_info=$(dbseek fornecedor id "$identificador")
		else
			fornecedor_info=$(dbseek fornecedor nome "$identificador" "$IsHeader" "$IsLike")
		fi
		if [[ -z "$fornecedor_info" ]]; then
			alerta 19 10 "$(gettext "Fornecedor não encontrado nos parâmetros informados")" "${Acores[msgerror]}"
			continue
		fi
		IFS='|' read -r fornecedor_id fornecedor_data fornecedor_nome fornecedor_ende fornecedor_cida fornecedor_esta fornecedor_cnpj <<<"$fornecedor_info"

		while true; do
			get 13 11 "$(gettext "Nome")                 : " nome "$fornecedor_nome" "${Acores[box]}" 78 || return
			if [[ -n "$nome" ]]; then
				break
			else
				if yesno 19 10 "$(gettext "O nome não pode ser em branco. Cancelar?")"; then
					return
				fi
			fi
		done

		get 14 11 "$(gettext "Endereço")             : " ende "$fornecedor_ende" "${Acores[box]}" 78 || return
		get 15 11 "$(gettext "Cidade")               : " cida "$fornecedor_cida" "${Acores[box]}" 78 || return
		get 16 11 "$(gettext "Estado")               : " esta "$fornecedor_esta" "${Acores[box]}" 78 || return

		while true; do
			get 17 11 "$(gettext "CNPJ/CPF")             : " cnpj "$fornecedor_cnpj" "${Acores[box]}" 78 || return
			if [[ -z "$cnpj" ]]; then
				break
			elif validar_cnpj_cpf "$cnpj"; then
				break
			else
				alerta 19 10 "$(gettext "CNPJ/CPF inválido")" "${Acores[msgerror]}"
			fi
		done

		if yesno 19 10 "$(gettext "Confirma inclusão/atualização do fornecedor?")"; then
			nome=${nome^^}
			ende=${ende^^}
			cida=${cida^^}
			esta=${esta^^}
			[[ -n "$cnpj" ]] && cnpj="$(formatar_cnpj_cpf "$cnpj")"
			local nome_esc="$(sql_escape "$nome")"
			local ende_esc="$(sql_escape "$ende")"
			local cida_esc="$(sql_escape "$cida")"
			local esta_esc="$(sql_escape "$esta")"
			local cnpj_esc="$(sql_escape "$cnpj")"
			query="INSERT OR REPLACE INTO fornecedor (id,data, nome, ende, cida, uf, cnpj) VALUES (
		        (SELECT id FROM fornecedor WHERE id='$fornecedor_id'),
				'$data_dia', '$nome_esc', '$ende_esc', '$cida_esc', '$esta_esc', '$cnpj_esc'
			);"

			if sqlite3 "$database" "$query"; then
				alerta 19 10 "$Registro_efetuado_com_sucesso" "${Acores[msgok]}"
			else
				alerta 19 10 "$Erro_no_cadastro_atualizacao_do_registro" "${Acores[msgerror]}"
			fi
		else
			alerta 19 10 "$(gettext "Inclusão/alteração não efetuada.")" "${Acores[msgerror]}"
		fi
	done
}

function fornecedor_exclusao() {
	local xtitle="$(gettext "EXCLUSÃO DE FORNECEDOR")"
	local consulta_sql
	local resultado
	local identificador
	local IsHeader=0
	local IsLike=1
	local fornecedor_id fornecedor_data fornecedor_nome fornecedor_ende fornecedor_cida fornecedor_esta fornecedor_cnpj
	local fornecedor_info
	local query

	while true; do
		tela
		titulo 1 "$xtitle" "${Acores[statussup]}"
		box 11 10 8 $(($(lastcol) - 11)) "$xtitle" "${Acores[box]}"
		print 12 11 "$(gettext "ID/Nome")              : "
		print 13 11 "$(gettext "Nome")                 : "
		print 14 11 "$(gettext "Endereço")             : "
		print 15 11 "$(gettext "Cidade")               : "
		print 16 11 "$(gettext "Estado")               : "
		print 17 11 "$(gettext "CNPJ/CPF")             : "

		get 12 11 "$(gettext "ID/Nome")              : " identificador || return
		if [[ -z "$identificador" ]]; then
			setpos 19 10
			if readconf "$(gettext "ID/Nome não pode ser em branco. Cancelar?")"; then
				return
			fi
			continue
		fi

		identificador=${identificador^^}
		if [[ $identificador =~ ^[0-9]+$ ]]; then
			fornecedor_info=$(dbseek 'fornecedor' 'id' "$identificador")
		else
			fornecedor_info=$(dbseek 'fornecedor' 'nome' "$identificador" "$IsHeader" "$IsLike")
		fi

		if [[ -z "$fornecedor_info" ]]; then
			msgerror "$(gettext "Nenhum fornecedor encontrado nos parâmetros informados")" "" 10
			continue
		else
			IFS='|' read -r fornecedor_id fornecedor_data fornecedor_nome fornecedor_ende fornecedor_cida fornecedor_esta fornecedor_cnpj <<<"$fornecedor_info"
			print 12 34 "$fornecedor_id" "$yellow"
			print 13 34 "$fornecedor_nome" "$yellow"
			print 14 34 "$fornecedor_ende" "$yellow"
			print 15 34 "$fornecedor_cida" "$yellow"
			print 16 34 "$fornecedor_esta" "$yellow"
			print 17 34 "$fornecedor_cnpj" "$yellow"
			setpos 19 10
			if readnotconf "$(gettext "Confirma exclusão do fornecedor?")"; then
				if [[ $identificador =~ ^[0-9]+$ ]]; then
					query="DELETE FROM fornecedor WHERE id='$identificador';"
				else
					local identificador_esc="$(sql_escape "$identificador")"
					query="DELETE FROM fornecedor WHERE nome='$identificador_esc';"
				fi
				if sqlite3 "$database" "$query"; then
					msgok "$Registro_removido_com_sucesso"
				else
					msgok "$Erro_na_remocao_do_registro" "" 10
				fi
			fi
		fi
	done
}

# Exibe uma tela de seleção (setas + Enter) com os fornecedores cadastrados
# e devolve (via echo) o id do fornecedor escolhido, ou nada se cancelado (ESC)
# ou se não houver fornecedores cadastrados.
function fornecedor_selecionar() {
	local xtitle="$(gettext "SELECIONAR FORNECEDOR")"
	local fornecedores_info
	local -a ids=()
	local -a itens=()
	local id nome
	local opcao
	local tecla_residual

	# Resultado devolvido via variável global (não por echo/$()): a função
	# desenha tela (tela/titulo/show_menu escrevem direto no terminal via
	# stdout), e capturar sua saída com $(...) engoliria TODA essa
	# renderização junto com o valor de retorno, deixando a tela em branco.
	FORNECEDOR_SELECIONADO_ID=""

	# Descarta qualquer tecla residual da tela anterior (ex: o Enter que
	# confirmou o campo em branco) antes de montar esta tela. Como nada
	# ainda foi desenhado, é seguro: o usuário não pode estar reagindo
	# a algo que ele ainda não viu.
	while read -rsn1 -t 0.01 tecla_residual; do :; done

	fornecedores_info=$(sqlite3 "$database" "SELECT id, nome FROM fornecedor ORDER BY nome;")

	if [[ -z "$fornecedores_info" ]]; then
		msgerror "$(gettext "Nenhum fornecedor cadastrado")"
		return 1
	fi

	while IFS='|' read -r id nome; do
		ids+=("$id")
		itens+=("$(printf "%-5s %s" "$id" "$nome")")
	done <<<"$fornecedores_info"

	tela
	titulo 1 "$xtitle" "${Acores[statussup]}"
	show_menu 11 10 "$xtitle" "${itens[@]}"
	opcao="$?"

	if ((opcao == 0)); then
		return 1 # ESC / cancelado
	fi

	FORNECEDOR_SELECIONADO_ID="${ids[$((opcao - 1))]}"
	return 0
}

function fornecedor_pesquisa() {
	local xtitle="$(gettext "PESQUISAR FORNECEDOR")"
	local identificador
	local fornecedor_info
	local id_ini
	local id_fim
	local IsHeader=0
	local IsLike=1
	local id data nome ende cida uf cnpj
	local -a linhas_fornecedor
	local Max_field_width

	while true; do
		tela
		titulo 1 "$xtitle" "${Acores[statussup]}"
		box "$nTop" 0 3 $(($(lastcol) - 1)) "$xtitle" "${Acores[box]}"
		get $((nTop + 1)) 1 "$(gettext "Pesquisar por: nome, id <x>|<x-y> ou *=tudo") : " identificador || return

		[[ -z "$identificador" ]] && return
		[[ "$identificador" == "*" ]] && identificador=

		mensagem "$xtitle" "$(gettext "Processando...")" 0 "$yellow"

		if [[ $identificador =~ ^[0-9]+$ ]]; then
			fornecedor_info=$(dbseek 'fornecedor' 'id' "$identificador")
		elif [[ $identificador =~ ^([0-9]+)-([0-9]+)$ ]]; then
			id_ini=${BASH_REMATCH[1]}
			id_fim=${BASH_REMATCH[2]}
			fornecedor_info=$(sqlite3 $database "SELECT * FROM fornecedor WHERE id >= $id_ini AND id <= $id_fim;")
		else
			fornecedor_info=$(dbseek 'fornecedor' 'nome' "$identificador" "$IsHeader" "$IsLike")
		fi

		if [[ -z "$fornecedor_info" ]]; then
			msgerror "$(gettext "Nenhum fornecedor encontrado nos parâmetros informados")" "" 10
			continue
		fi

		linhas_fornecedor=()
		while IFS='|' read -r id data nome ende cida uf cnpj; do
			linhas_fornecedor+=("$id|$(convert_date_to_ptBR "$data")|$nome|$ende|$cida|$uf|$cnpj")
		done <<<"$fornecedor_info"

		calcular_larguras "5|10|40|40|25|2|18" "0|0|1|1|1|0|0" "$(($(lastcol) - 2))"
		Max_field_width="$CALC_LARGURAS_RESULT"

		browse_tabela "$((nTop + 3))" 0 "$(($(lastrow) - $((nTop + 3))))" "$(($(lastcol) - 1))" "$xtitle" \
			"ID|DATA|NOME FORNECEDOR|ENDEREÇO|CIDADE|UF|CNPJ/CPF" "$Max_field_width" linhas_fornecedor "${Acores[box]}"
	done
}

function relatorio_vendas_diarias() {
	local xtitle="${Relatorio_de^^} ${Vendas_Diarias^^}"
	local query_result
	local dini dfim
	local data_inicio="01-$(date +"%m-%Y")"
	local data_fim=$(date +"%d-%m-%Y")
	local total_mes current_mes
	local new_mes total data
	local Max_field_width
	local qtd_itens num_vendas qtd_mes vendas_mes
	local ticket_medio ticket_medio_mes total_mes_fmt total_fmt
	local dini_ptbr dfim_ptbr xtitle_periodo
	local total_geral qtd_geral vendas_geral ticket_medio_geral total_geral_fmt
	local -a linhas_vendas

	tela
	titulo 1 "$xtitle" "${Acores[statussup]}"
	box "$nTop" 0 4 $(($(lastcol) - 1)) "$xtitle" "${Acores[box]}"
	print $((nTop + 1)) 1 "$(gettext "Data Inicial")    : "
	print $((nTop + 2)) 1 "$(gettext "Data Final")      : "

	while true; do
		get $((nTop + 1)) 1 "$(gettext "Data Inicial")    : " dini "$data_inicio" || return
		if [[ -n "$dini" ]]; then
			if validar_data "$dini"; then
				break
			else
				msgerror "$(gettext "Data inválida")"
				continue
			fi
		else
			setpos 12 01
			if readconf "$(gettext "A data não pode ser em branco. Cancelar?")"; then
				return
			fi
		fi
	done

	while true; do
		get $((nTop + 2)) 1 "$(gettext "Data Final")      : " dfim "$data_fim" || return
		if [[ -n "$dfim" ]]; then
			if validar_data "$dfim"; then
				break
			else
				msgerror "$(gettext "Data inválida")"
				continue
			fi
		else
			setpos 12 01
			if readconf "$(gettext "A data não pode ser em branco. Cancelar?")"; then
				return
			fi
		fi
	done

	dini_ptbr="$dini"
	dfim_ptbr="$dfim"
	dini=$(convert_date_to_US "$dini")
	dfim=$(convert_date_to_US "$dfim")

	# Consulta para obter resultados diários agrupados por ano e mês
	mensagem "$xtitle" "$(gettext "Processando...")" 0 "$yellow"
	query_result=$(sqlite3 "$database" "SELECT date(data), SUM(total), SUM(quantidade), COUNT(DISTINCT docnr) FROM vendas WHERE date(data) BETWEEN '$dini' AND '$dfim' GROUP BY date(data) ORDER BY date(data) ASC")

	if [[ -z "${query_result}" ]]; then
		msgok "" "" -1
		return
	fi

	total_mes=0
	qtd_mes=0
	vendas_mes=0
	total_geral=0
	qtd_geral=0
	vendas_geral=0
	current_mes=
	linhas_vendas=()
	while IFS='|' read -r data total qtd_itens num_vendas; do
		new_mes="${data:5:2}" # SQLite date() sempre devolve AAAA-MM-DD
		if [[ -n "$current_mes" && "$current_mes" != "$new_mes" ]]; then
			arredondar_moeda "$total_mes"
			total_mes_fmt="${ARREDONDAR_MOEDA_RESULT/./,}"
			ticket_medio_mes=0
			((vendas_mes > 0)) && ticket_medio_mes=$(echo "$total_mes / $vendas_mes" | bc -l)
			arredondar_moeda "$ticket_medio_mes"
			linhas_vendas+=("SOMA MENSAL|$total_mes_fmt|$qtd_mes|$vendas_mes|${ARREDONDAR_MOEDA_RESULT/./,}|$red")
			linhas_vendas+=("")
			total_mes=0
			qtd_mes=0
			vendas_mes=0
		fi

		total_mes=$(echo "$total_mes + $total" | bc -l)
		qtd_mes=$((qtd_mes + qtd_itens))
		vendas_mes=$((vendas_mes + num_vendas))

		total_geral=$(echo "$total_geral + $total" | bc -l)
		qtd_geral=$((qtd_geral + qtd_itens))
		vendas_geral=$((vendas_geral + num_vendas))

		arredondar_moeda "$total"
		total_fmt="${ARREDONDAR_MOEDA_RESULT/./,}"
		ticket_medio=0
		((num_vendas > 0)) && ticket_medio=$(echo "$total / $num_vendas" | bc -l)
		arredondar_moeda "$ticket_medio"
		linhas_vendas+=("$(convert_date_to_ptBR "$data")|$total_fmt|$qtd_itens|$num_vendas|${ARREDONDAR_MOEDA_RESULT/./,}")
		current_mes="$new_mes"
	done <<<"${query_result}"
	arredondar_moeda "$total_mes"
	total_mes_fmt="${ARREDONDAR_MOEDA_RESULT/./,}"
	ticket_medio_mes=0
	((vendas_mes > 0)) && ticket_medio_mes=$(echo "$total_mes / $vendas_mes" | bc -l)
	arredondar_moeda "$ticket_medio_mes"
	linhas_vendas+=("SOMA MENSAL|$total_mes_fmt|$qtd_mes|$vendas_mes|${ARREDONDAR_MOEDA_RESULT/./,}|$red")

	# SOMA GERAL: soma de todo o período consultado (todos os meses),
	# não só do último mês - sempre a última linha do relatório.
	linhas_vendas+=("")
	ticket_medio_geral=0
	((vendas_geral > 0)) && ticket_medio_geral=$(echo "$total_geral / $vendas_geral" | bc -l)
	arredondar_moeda "$total_geral"
	total_geral_fmt="${ARREDONDAR_MOEDA_RESULT/./,}"
	arredondar_moeda "$ticket_medio_geral"
	linhas_vendas+=("SOMA GERAL|$total_geral_fmt|$qtd_geral|$vendas_geral|${ARREDONDAR_MOEDA_RESULT/./,}|$red")

	xtitle_periodo="$xtitle - $(gettext "PERÍODO") $dini_ptbr/$dfim_ptbr"

	calcular_larguras "10|10|9|9|12" "1|1|1|1|1" "$(($(lastcol) - 2))"
	Max_field_width="$CALC_LARGURAS_RESULT"

	browse_tabela "$((nTop + 4))" 0 "$(($(lastrow) - $((nTop + 4))))" "$(($(lastcol) - 1))" "$xtitle_periodo" \
		"DATA|TOTAL DIA|QTD ITENS|Nº VENDAS|TICKET MÉDIO" "$Max_field_width" linhas_vendas "${Acores[box]}"
}

function relatorio_produtos_vendidos() {
	local xtitle="${Relatorio_de^^} ${Produtos_Vendidos^^}"
	local current_index index
	local identificador
	local query result
	local id_ini id_fim
	local compare
	local fornecedor data docnr id un produto quantidade preco total codebar
	local total_formatado
	local Max_field_width
	local -a linhas_venda

	while true; do
		tela
		titulo 1 "$xtitle" "${Acores[statussup]}"
		box "$nTop" 0 4 $(($(lastcol) - 1)) "$xtitle" "${Acores[box]}"
		print $((nTop + 1)) 1 "$(gettext "Pesquisar por: docnr, data <dd-mm-aaaa>, id <x>|<x-y>, f<id>, ou *=tudo") : "
		print $((nTop + 2)) 1 "$(gettext "Agrupar : n=docnr, d=data, i=id, f=forn ou *=nenhum") : "

		get $((nTop + 1)) 1 "$(gettext "Pesquisar por: docnr, data <dd-mm-aaaa>, id <x>|<x-y>, f<id>, ou *=tudo") : " identificador || return
		get $((nTop + 2)) 1 "$(gettext "Agrupar : n=docnr, d=data, i=id, f=forn ou *=nenhum") : " index || return

		[[ -z "$identificador" ]] && return
		[[ "$identificador" == "*" ]] && identificador=

		mensagem "$xtitle" "$(gettext "Processando...")" 0 "$yellow"

		# por docnr
		if [[ $identificador =~ ^[0-9]{7}$ ]]; then
			query="SELECT produtos.fabricante, vendas.data, vendas.docnr, produtos.id, produtos.un, produtos.nome, vendas.quantidade, vendas.preco, vendas.total
				FROM vendas
				JOIN produtos ON vendas.id = produtos.id
				WHERE vendas.docnr = '$identificador'
				ORDER BY vendas.data, vendas.docnr;"
			result=$(sqlite3 "$database" "$query")

		# por id
		elif [[ $identificador =~ ^[0-9]+$ ]]; then
			query="SELECT produtos.fabricante, vendas.data, vendas.docnr, produtos.id, produtos.un, produtos.nome, vendas.quantidade, vendas.preco, vendas.total
				FROM vendas
				JOIN produtos ON vendas.id = produtos.id
				WHERE vendas.id = '$identificador'
				ORDER BY vendas.data, vendas.docnr;"
			result=$(sqlite3 "$database" "$query")

		#id parcial
		elif [[ $identificador =~ ^([0-9]+)-([0-9]+)$ ]]; then
			id_ini="${BASH_REMATCH[1]}"
			id_fim="${BASH_REMATCH[2]}"
			query="SELECT produtos.fabricante, vendas.data, vendas.docnr, produtos.id, produtos.un, produtos.nome, vendas.quantidade, vendas.preco, vendas.total
				FROM vendas
				JOIN produtos ON vendas.id = produtos.id
				WHERE vendas.id >= '$id_ini' AND vendas.id <= '$id_fim'
				ORDER BY vendas.data, vendas.docnr;"
			result=$(sqlite3 "$database" "$query")

		# por fornecedor
		elif [[ $identificador =~ ^[fF]([0-9]+)$ ]]; then
			identificador=${BASH_REMATCH[1]}
			query="SELECT produtos.fabricante, vendas.data, vendas.docnr, produtos.id, produtos.un, produtos.nome, vendas.quantidade, vendas.preco, vendas.total
				FROM vendas
				JOIN produtos ON vendas.id = produtos.id
				WHERE produtos.fabricante = '$identificador'
				ORDER BY vendas.data, vendas.docnr;"
			result=$(sqlite3 "$database" "$query")

		# por data
		elif [[ $identificador =~ ^[0-9]{2}-[0-9]{2}-[0-9]{4}$ || $identificador =~ ^[0-9]{2}/[0-9]{2}/[0-9]{4}$ ]]; then
			if ! validar_data "$identificador"; then
				msgerror "$Formato_de_data_invalida"
				continue
			fi
			identificador=$(convert_date_to_US "$identificador")
			query="SELECT produtos.fabricante, vendas.data, vendas.docnr, produtos.id, produtos.un, produtos.nome, vendas.quantidade, vendas.preco, vendas.total
				FROM vendas
				JOIN produtos ON vendas.id = produtos.id
				WHERE vendas.data = '$identificador'
				ORDER BY vendas.data, vendas.docnr;"
			result=$(sqlite3 "$database" "$query")

		# todos
		else
			query="SELECT produtos.fabricante, vendas.data, vendas.docnr, produtos.id, produtos.un, produtos.nome, vendas.quantidade, vendas.preco, vendas.total
				FROM vendas
				JOIN produtos ON vendas.id = produtos.id
				ORDER BY vendas.data, vendas.docnr;"
			result=$(sqlite3 "$database" "$query")
		fi

		if [ -z "$result" ]; then
			msgerror "$Nenhum_produto_encontrado_nos_parametros_informados" "" 10
			continue
		fi

		current_index=""
		linhas_venda=()
		while IFS='|' read -r fornecedor data docnr id un produto quantidade preco total codebar; do
			case "$index" in
			n) compare="$docnr" ;;
			d) compare="$data" ;;
			i) compare="$id" ;;
			f) compare="$fornecedor" ;;
			esac
			if [[ "$current_index" != "" && "$compare" != "$current_index" ]]; then
				linhas_venda+=("")
			fi
			dec_mult "$quantidade" "$preco"
			total_formatado="${DEC_RESULT/./,}"
			formatar_2_casas "$preco"
			preco="$FORMATAR_2_CASAS_RESULT"
			linhas_venda+=("$(convert_date_to_ptBR "$data")|$docnr|$fornecedor|$id|$produto|$un|$quantidade|${preco/./,}|$total_formatado")
			case "$index" in
			n) current_index="$docnr" ;;
			d) current_index="$data" ;;
			i) current_index="$id" ;;
			f) current_index="$fornecedor" ;;
			esac
		done <<<"$result"

		calcular_larguras "10|7|5|5|40|2|5|10|10" "0|0|0|0|1|0|0|0|0" "$(($(lastcol) - 2))"
		Max_field_width="$CALC_LARGURAS_RESULT"

		browse_tabela "$((nTop + 4))" 0 "$(($(lastrow) - $((nTop + 4))))" "$(($(lastcol) - 1))" "$xtitle" \
			"DATA|DOCNR|FORN|ID|DESCRIÇÃO DO PRODUTO|UN|QTD|PREÇO|TOTAL" "$Max_field_width" linhas_venda "${Acores[box]}"
	done
}

function relatorio_entradas_produtos() {
	local xtitle="$(gettext "RELATÓRIO ENTRADAS DE PRODUTOS")"
	local identificador query result
	local dini dfim
	local id_ini id_fim
	local fornecedor id data custo docnr un produto quantidade total
	local index
	local compare
	local current_index
	local Max_field_width
	local -a linhas_compra

	while true; do
		tela
		titulo 1 "$xtitle" "${Acores[statussup]}"
		box "$nTop" 0 4 $(($(lastcol) - 1)) "$xtitle" "${Acores[box]}"
		print $((nTop + 1)) 1 "$(gettext "Pesquisar por: docnr, data <dd-mm-aaaa>, id <x>|<x-y>, f<id>, ou *=tudo") : "
		print $((nTop + 2)) 1 "$(gettext "Agrupar : n=docnr, d=data, i=id, f=forn ou *=nenhum") : "

		get $((nTop + 1)) 1 "$(gettext "Pesquisar por: docnr, data <dd-mm-aaaa>, id <x>|<x-y>, f<id>, ou *=tudo") : " identificador || return
		get $((nTop + 2)) 1 "$(gettext "Agrupar : n=docnr, d=data, i=id, f=forn ou *=nenhum") : " index || return

		[[ -z "$identificador" ]] && return
		[[ "$identificador" == "*" ]] && identificador=

		mensagem "$xtitle" "$(gettext "Processando...")" 0 "$yellow"

		# por data parcial
		if [[ "$identificador" =~ ^[0-9]{2}-[0-9]{2}-[0-9]{4}\s[0-9]{2}-[0-9]{2}-[0-9]{4}$ ]]; then
			dini="${BASH_REMATCH[1]}"
			dfim="${BASH_REMATCH[2]}"
			if ! validar_data "$dini"; then
				msgerror "$Formato_de_data_invalida"
				continue
			fi
			if ! validar_data "$dfim"; then
				msgerror "$Formato_de_data_invalida"
				continue
			fi
			query="SELECT fornecedor, compras.id, compras.data, docnr, produtos.un, produtos.nome, quantidade, custo, total
				FROM compras
				JOIN produtos ON compras.id = produtos.id
				WHERE compras.data BETWEEN '$(convert_date_to_US "$dini")' AND '$(convert_date_to_US "$dfim")'
				ORDER BY compras.docnr;"
			result=$(sqlite3 "$database" "$query")

		# por fornecedor
		elif [[ $identificador =~ ^[fF]([0-9]+)$ ]]; then
			identificador=${BASH_REMATCH[1]}
			query="SELECT fornecedor, compras.id, compras.data, docnr, produtos.un, produtos.nome, quantidade, custo, total
				FROM compras
				JOIN produtos ON compras.id = produtos.id
				WHERE compras.fornecedor = '$identificador'
				ORDER BY compras.docnr;"
			result=$(sqlite3 "$database" "$query")

		# por id / por docnr
		elif [[ $identificador =~ ^[0-9]+$ ]]; then
			query="SELECT fornecedor, compras.id, compras.data, docnr, produtos.un, produtos.nome, quantidade, custo, total
				FROM compras
				JOIN produtos ON compras.id = produtos.id
				WHERE compras.docnr = '$identificador'
				ORDER BY compras.docnr;"
			result=$(sqlite3 "$database" "$query")

			if [ -z "$result" ]; then
				query="SELECT fornecedor, compras.id, compras.data, docnr, produtos.un, produtos.nome, quantidade, custo, total
					FROM compras
					JOIN produtos ON compras.id = produtos.id
					WHERE compras.id = '$identificador'
					ORDER BY compras.docnr;"
				result=$(sqlite3 "$database" "$query")
			fi

		#id parcial
		elif [[ $identificador =~ ^([0-9]+)-([0-9]+)$ ]]; then
			id_ini="${BASH_REMATCH[1]}"
			id_fim="${BASH_REMATCH[2]}"
			query="SELECT fornecedor, compras.id, compras.data, docnr, produtos.un, produtos.nome, quantidade, custo, total
				FROM compras
				JOIN produtos ON compras.id = produtos.id
				WHERE compras.id >= '$id_ini' AND compras.id <= '$id_fim'
				ORDER BY compras.data, compras.docnr;"
			result=$(sqlite3 "$database" "$query")

		# por data
		elif [[ $identificador =~ ^[0-9]{2}-[0-9]{2}-[0-9]{4}$ ]]; then
			if ! validar_data "$identificador"; then
				msgerror "$Formato_de_data_invalida"
				continue
			fi
			query="SELECT fornecedor, compras.id, compras.data, docnr, produtos.un, produtos.nome, quantidade, custo, total
				FROM compras
				JOIN produtos ON compras.id = produtos.id
				WHERE compras.data = '$(convert_date_to_US "$identificador")'
				ORDER BY compras.docnr;"
			result=$(sqlite3 "$database" "$query")

		# por docnr
		elif [[ $identificador =~ ^[0-9]{7}$ ]]; then
			query="SELECT fornecedor, compras.id, compras.data, docnr, produtos.un, produtos.nome, quantidade, custo, total
				FROM compras
				JOIN produtos ON compras.id = produtos.id
				WHERE compras.docnr = '$identificador'
				ORDER BY compras.docnr;"
			result=$(sqlite3 "$database" "$query")

		# *=todos
		else
			query="SELECT fornecedor, compras.id, compras.data, docnr, produtos.un, produtos.nome, quantidade, custo, total
				FROM compras
				JOIN produtos ON compras.id = produtos.id
				ORDER BY compras.docnr;"
			result=$(sqlite3 "$database" "$query")
		fi

		if [ -z "$result" ]; then
			msgerror "$(gettext "Não consta entradas nos parâmetros informados")" "" 5
			continue
		fi

		current_index=""
		linhas_compra=()
		while IFS='|' read -r fornecedor id data docnr un produto quantidade custo total; do
			case "$index" in
			n) compare="$docnr" ;;
			d) compare="$data" ;;
			i) compare="$id" ;;
			f) compare="$fornecedor" ;;
			esac
			if [[ "$current_index" != "" && "$compare" != "$current_index" ]]; then
				linhas_compra+=("")
			fi
			formatar_2_casas "$custo"
			custo="$FORMATAR_2_CASAS_RESULT"
			linhas_compra+=("$fornecedor|$(convert_date_to_ptBR "$data")|$docnr|$id|$produto|$un|$quantidade|${custo/./,}")
			case "$index" in
			n) current_index="$docnr" ;;
			d) current_index="$data" ;;
			i) current_index="$id" ;;
			f) current_index="$fornecedor" ;;
			esac
		done <<<"$result"

		calcular_larguras "5|10|7|5|40|2|5|10" "0|0|0|0|1|0|0|0" "$(($(lastcol) - 2))"
		Max_field_width="$CALC_LARGURAS_RESULT"

		browse_tabela "$((nTop + 4))" 0 "$(($(lastrow) - $((nTop + 4))))" "$(($(lastcol) - 1))" "$xtitle" \
			"FORN|DATA|DOCNR|ID|DESCRIÇÃO DO PRODUTO|UN|QTD|CUSTO" "$Max_field_width" linhas_compra "${Acores[box]}"
	done
}

function registrar_venda() {
	local total_venda="$1"
	local data_venda="$(sh_date)"
	local docnr="$(obterProximoNumeroDocumento 'vendas')"
	local key produto
	local id produto_nome quantidade valor

	for key in "${!lista_produtos[@]}"; do
		produto="${lista_produtos[$key]}"
		IFS='|' read -r id produto_nome quantidade valor <<<"$produto"
		sqlite3 "$database" "INSERT INTO vendas (id, data, quantidade, preco, total, docnr) VALUES ('$id', '$data_venda', '$quantidade', '$valor', '$total_venda', '$docnr');"
	done
#	mensagem "${_SYSTEM_}" "$(gettext "Registro de venda efetuado")" 0 "${green}"
	msgok "$(gettext "Registro de venda efetuado")"
}

function atualizar_estoque_vendas() {
	local key
	local id produto_nome quantidade valor
	local produto

	for key in "${!lista_produtos[@]}"; do
		produto="${lista_produtos[$key]}"
		IFS='|' read -r id produto_nome quantidade valor <<<"$produto"
		sqlite3 "$database" "UPDATE produtos SET estoque = COALESCE(estoque, 0) - $quantidade WHERE id='$id';"
	done
#	mensagem "${_SYSTEM_}" "$(gettext "Baixa de estoque efetuado")" 0 "${green}"
	msgok "$(gettext "Baixa de estoque efetuado")"
}

function realizar_venda() {
	local xtitle="$(gettext "CUPOM PDV")"
	local nTop=10
	local nRight=71
	declare -A lista_produtos
	local IsHeader=0
	local IsLike=1
	local nrow=0
	local produto
	local subtotal
	local identificador
	local quantidade
	local valor_formatado
	local padding=71
	local itens=0
	local total_venda
	local key
	local produto_info
	local id produto_nome unidade estoque valor codebar
	local produto_id produto_quantidade produto_valor nova_quantidade
	local efetivo

	local largura_descricao=40
	function realizar_venda::imprimir_cabecalho() {
		local Coordenadas="$((nTop))|0|$((itens + 7))"
		local Cabecalho="ID|DESCRIÇÃO DO PRODUTO|QTD|PREÇO|TOTAL"
		calcular_larguras "5|40|5|8|8" "0|1|0|0|0" "$(lastcol)"
		local Max_field_width="$CALC_LARGURAS_RESULT"
		largura_descricao="${CALC_LARGURAS_RESULT#*|}"
		largura_descricao="${largura_descricao%%|*}"
		padding=$((5 + largura_descricao + 5 + 8 + 8 + 5))
		local Color="${Acores[dispbox]}"
		local Align_field='left'
		dispbox "$Coordenadas" "$Cabecalho" "$Max_field_width" "$Color" "$Align_field"
	}

	while true; do
		sh_fundo
		tela
		titulo 1 "${Realizar_Venda_Saida^^} - $xtitle" "${Acores[statussup]}"
		itens="${#lista_produtos[@]}"
		realizar_venda::imprimir_cabecalho
		nrow=11
		total_venda=0
		for key in "${!lista_produtos[@]}"; do
			produto="${lista_produtos[$key]}"
			IFS='|' read -r id produto_nome quantidade valor <<<"$produto"
			dec_mult "$quantidade" "$valor"
			subtotal="${DEC_RESULT/./,}"
			valor_formatado="${valor/./,}"
			produto_nome="${produto_nome:0:$largura_descricao}"
			print $nrow 01 "$(printf "${yellow}%5s %-*s %5s %8s %8s${reset}\n" "$id" "$largura_descricao" "$produto_nome" "$quantidade" "$valor_formatado" "$subtotal")"
			dec_add "$total_venda" "$DEC_RESULT"
			total_venda="$DEC_RESULT"
			((++nrow))
		done
		print $nrow 00 "├$(replicate "─" "$((padding))")┤"
		((++nrow))
		print $nrow 01 "$(printf "${red}%5s %-*s %5s %8s$%8s${reset}\n" "" "$largura_descricao" "SUBTOTAL" "" "" "${total_venda/./,}")"
		((++nrow))
		print $nrow 00 "├$(replicate "─" "$((padding))")┤"
		((++nrow))
		get $nrow 01 "$(gettext "ID/nome/CodeBar (em branco=concluir)"): " identificador

		[[ -z "$identificador" ]] && break # em branco? concluir venda

		identificador=${identificador^^}
		#código de barras
		if [[ $identificador =~ ^[0-9]{13}$ ]]; then
			produto_info=$(dbseek 'produtos' 'codebar' "$identificador")
		#id
		elif [[ $identificador =~ ^[0-9]+$ ]]; then
			produto_info=$(dbseek 'produtos' 'id' "$identificador")
		else
			produto_info=$(dbseek 'produtos' 'nome' "$identificador" "$IsHeader" "$IsLike")
		fi
		if [[ -z "$produto_info" ]]; then
			mensagem "${xtitle}" "$(gettext "Produto não encontrado")"
			continue
		fi
		IFS='|' read -r id produto_nome unidade estoque valor codebar <<<"$produto_info"
		print $nrow 39 "${yellow}$produto_nome${reset}"
		((++nrow))

		# Solicita a quantidade e verifica se não está em branco
		get $nrow 01 "$(gettext "Quantidade (0 para remover o item)")  : " quantidade
		if [[ "$quantidade" =~ ^[0-9]+$ || "$quantidade" =~ ^-[0-9]+$ ]]; then
			# Remove zero à esquerda (evita erro de octal em comparações/aritmética)
			if [[ "$quantidade" == -* ]]; then
				quantidade="-$((10#${quantidade#-}))"
			else
				quantidade=$((10#$quantidade))
			fi
			if [[ "$quantidade" = 0 ]]; then
				if [[ -v lista_produtos[$id] ]]; then
					unset 'lista_produtos[$id]'
					continue
				else
					mensagem "${xtitle}" "$(gettext "Quantidade inválida ou item não tem na lista")"
					continue
				fi
			fi
		else
			mensagem "${xtitle}" "$(gettext "Quantidade inválida!")"
			continue
		fi

		if [[ "$estoque" -lt "$quantidade" ]]; then
			mensagem "${xtitle}" "$(gettext "Quantidade insuficiente de") '$produto_nome' $(gettext "no estoque - restam"): $estoque"
			continue
		fi
		dec_mult "$quantidade" "$valor"
		subtotal="$DEC_RESULT"

		# Atualiza o array associativo com informações do produto
		if [[ -v lista_produtos[$id] ]]; then
			# Se o produto já existe na lista, atualiza a quantidade
			produto="${lista_produtos[$id]}"
			IFS='|' read -r produto_id produto_nome produto_quantidade produto_valor <<<"$produto"
			nova_quantidade=$((produto_quantidade + quantidade))
			lista_produtos[$id]="$produto_id|$produto_nome|$nova_quantidade|$valor"
		else
			# Se o produto não existe na lista, adiciona
			lista_produtos[$id]="$id|$produto_nome|$quantidade|$valor"
		fi
		dec_add "$total_venda" "$subtotal"
		total_venda="$DEC_RESULT"
	done

	if [[ "${#lista_produtos[@]}" -gt 0 ]]; then
		((++nrow))
		setpos $nrow 1
		if readconf "$(gettext "Confirma o fechamento do CUPOM?")" "" 1; then
			registrar_venda "$total_venda"
			atualizar_estoque_vendas
		fi
		print $nrow 1 "$(replicate ' ' 40)"
		get   $nrow 1  "Valor para troco)                   : " efetivo '' ${white}
      print $nrow 50 "Troco:" ${white}
      dec_sub "$efetivo" "$total_venda"
      print $nrow 57 "$DEC_RESULT" ${red}
		inkey 20
	fi
}

function produtos_entradas() {
	local xtitle="$(gettext "ENTRADAS DE PRODUTOS")"
	declare -gA lista_produtos=() # Declarar um array associativo para armazenar produtos
	declare -gA notafiscal=()
	local nTop=10
	local nRight=71
	local nrow=0
	local produto
	local subtotal
	local identificador
	local quantidade
	local valor_formatado
	local padding=71
	local itens=0
	local total_compra
	local key
	local produto_info
	local id produto_nome unidade estoque preco codebar
	local custo custo_formatado
	local produto_id produto_quantidade produto_custo nova_quantidade
	local fornecedor_info
	local data nome ende cida esta cnpj docnr

	local largura_descricao=40
	function produtos_entradas::imprimir_cabecalho() {
		local Coordenadas="$((nTop))|0|$((itens + 8))"
		local Cabecalho="ID|DESCRIÇÃO DO PRODUTO|QTD|PREÇO|TOTAL"
		calcular_larguras "5|40|5|8|8" "0|1|0|0|0" "$(lastcol)"
		local Max_field_width="$CALC_LARGURAS_RESULT"
		largura_descricao="${CALC_LARGURAS_RESULT#*|}"
		largura_descricao="${largura_descricao%%|*}"
		padding=$((5 + largura_descricao + 5 + 8 + 8 + 5))
		local Color="${Acores[dispbox]}"
		local Align_field='left'
		dispbox "$Coordenadas" "$Cabecalho" "$Max_field_width" "$Color" "$Align_field"
	}

	while true; do
		sh_fundo
		tela
		titulo 1 "$xtitle" "${Acores[statussup]}"
		itens="${#lista_produtos[@]}"
		produtos_entradas::imprimir_cabecalho
		nrow=11
		total_compra=0
		for key in "${!lista_produtos[@]}"; do
			produto="${lista_produtos[$key]}"
			IFS='|' read -r id produto_nome quantidade custo <<<"$produto"
			dec_mult "$quantidade" "$custo"
			subtotal="${DEC_RESULT/./,}"
			custo_formatado="${custo/./,}"
			produto_nome="${produto_nome:0:$largura_descricao}"
			print $nrow 01 "$(printf "${yellow}%5s %-*s %5s %8s %8s${reset}\n" "$id" "$largura_descricao" "$produto_nome" "$quantidade" "$custo_formatado" "$subtotal")"
			dec_add "$total_compra" "$DEC_RESULT"
			total_compra="$DEC_RESULT"
			((++nrow))
		done
		print $nrow 00 "├$(replicate "─" "$((padding))")┤"
		((++nrow))
		print $nrow 01 "$(printf "${red}%5s %-*s %5s %8s$%8s${reset}\n" "" "$largura_descricao" "SUBTOTAL" "" "" "${total_compra/./,}")"
		((++nrow))
		print $nrow 00 "├$(replicate "─" "$((padding))")┤"
		((++nrow))
		get $nrow 01 "$(gettext "ID/nome/CodeBar (em branco=concluir)"): " identificador

		[[ -z "$identificador" ]] && break
		identificador=${identificador^^}

		#código de barras
		if [[ $identificador =~ ^[0-9]{13}$ ]]; then
			produto_info=$(dbseek produtos codebar "$identificador")
		#id
		elif [[ $identificador =~ ^[0-9]+$ ]]; then
			produto_info=$(dbseek produtos id "$identificador")
		else
			produto_info=$(dbseek produtos nome "$identificador")
		fi

		if [[ -z "$produto_info" ]]; then
			mensagem "${xtitle}" "$(gettext "Produto não encontrado")"
			continue
		fi

		IFS='|' read -r id produto_nome unidade estoque preco codebar <<<"$produto_info"
		print $nrow 39 "${yellow}$produto_nome${reset}"
		((++nrow))

		# Solicita a quantidade e verifica se não está em branco
		get $nrow 01 "$(gettext "Quantidade (0 para remover o item)")  : " quantidade
		if [[ "$quantidade" =~ ^[0-9]+$ || "$quantidade" =~ ^-[0-9]+$ ]]; then
			# Remove zero à esquerda (evita erro de octal em comparações/aritmética)
			if [[ "$quantidade" == -* ]]; then
				quantidade="-$((10#${quantidade#-}))"
			else
				quantidade=$((10#$quantidade))
			fi
			if [[ "$quantidade" = 0 ]]; then
				if [[ -v lista_produtos[$id] ]]; then
					unset 'lista_produtos[$id]'
					continue
				else
					mensagem "${xtitle}" "$(gettext "Quantidade inválida ou item não tem na lista")"
					continue
				fi
			fi
		else
			mensagem "${xtitle}" "$(gettext "Quantidade inválida!")"
			continue
		fi

		# Solicita o preço como número inteiro ou decimal com ponto (ex: 4.99) e verifica se não está em branco
		((++nrow))
		while true; do
			get $nrow 01 "$(gettext "Preço custo (ex: 4.99 ou 5)")         : " custo
			if [[ -n "$custo" ]] && [[ $custo =~ ^[0-9]+(\.[0-9]+)?$ ]]; then
				break
			else
				mensagem "${xtitle}" "$(gettext "Formato inválido. Usar ponto decimal ex: 4.99 ou número inteiro.")"
			fi
		done
		dec_mult "$quantidade" "$custo"
		subtotal="$DEC_RESULT"

		# Atualiza o array associativo com informações do produto
		if [[ -v lista_produtos[$id] ]]; then
			# Se o produto já existe na lista, atualiza a quantidade
			produto="${lista_produtos[$id]}"
			IFS='|' read -r produto_id produto_nome produto_quantidade produto_custo <<<"$produto"
			nova_quantidade=$((produto_quantidade + quantidade))
			lista_produtos[$id]="$produto_id|$produto_nome|$nova_quantidade|$custo"
		else
			# Se o produto não existe na lista, adiciona
			lista_produtos[$id]="$id|$produto_nome|$quantidade|$custo"
		fi
		dec_add "$total_compra" "$subtotal"
		total_compra="$DEC_RESULT"
	done

	function produtos_entradas::dados_nff() {
		while true; do
			titulo 1 "$xtitle" "${Acores[statussup]}"
			box "$((nrow + 3))" 00 4 "$((nRight + 2))" "$(gettext "DADOS DA NFF")" "${Acores[box]}"
			# Solicita a descrição (nome) do produto e verifica se não está em branco
			print $((nrow + 4)) 01 "$(gettext "Fornecedor") : "
			print $((nrow + 5)) 01 "$(gettext "Docnr/NFF")  : "
			get $((nrow + 4)) 01 "$(gettext "Fornecedor") : " identificador

			if [[ -z "$identificador" ]]; then
				setpos $((nrow + 7)) 00
				if readconf "$(gettext "ID/Nome não pode ser em branco. Cancelar?")"; then
					return 1
				fi
				continue
			fi
			identificador=${identificador^^}
			if [[ $identificador =~ ^[0-9]+$ ]]; then
				fornecedor_info=$(dbseek fornecedor id "$identificador")
			else
				fornecedor_info=$(dbseek fornecedor nome "$identificador")
			fi
			if [[ -z "$fornecedor_info" ]]; then
				mensagem "${xtitle}" "$(gettext "Fornecedor não encontrado nos parâmetros informados")"
				continue
			fi
			IFS='|' read -r id data nome ende cida esta cnpj <<<"$fornecedor_info"
			print $((nrow + 4)) 14 "${azul}${nome}${reset}"
			get $((nrow + 5)) 01 "$(gettext "Docnr/NFF")  : " docnr "$(obterProximoNumeroDocumento 'compras')"
			notafiscal=([fornecedor]="$id" [nome]="$nome" [docnr]="$docnr")
			break
		done
		return 0
	}

	if [[ "${#lista_produtos[@]}" -gt 0 ]]; then
		((++nrow))
		setpos $nrow 1
		if readconf "$(gettext "Confirma a entrada desses produtos?")" "" 1; then
			if produtos_entradas::dados_nff; then
				registrar_compra "$total_compra"
				atualizar_estoque_compras
			fi
		fi
	fi
}

function registrar_compra() {
	local total_compra="$1"
	local data_compra="$(sh_date)"
	local fornecedor="${notafiscal[fornecedor]}"
	local docnr="${notafiscal[docnr]}"
	local key produto
	local id produto_nome quantidade custo

	# Iterar sobre os produtos vendidos no array associativo lista_produtos
	for key in "${!lista_produtos[@]}"; do
		produto="${lista_produtos[$key]}"
		IFS='|' read -r id produto_nome quantidade custo <<<"$produto"
		sqlite3 "$database" "INSERT INTO compras (id, fornecedor, data, docnr, quantidade, custo, total) VALUES ('$id', '$fornecedor', '$data_compra', '$docnr', '$quantidade', '$custo','$total_compra');"
	done
	msgok "$Registro_efetuado_com_sucesso"
	return 0
}

function atualizar_estoque_compras() {
	local key produto
	local id nome quantidade custo

	# Iterar sobre os produtos vendidos no array associativo lista_produtos
	for key in "${!lista_produtos[@]}"; do
		produto="${lista_produtos[$key]}"
		IFS='|' read -r id nome quantidade custo <<<"$produto"
		sqlite3 "$database" "UPDATE produtos SET estoque = COALESCE(estoque, 0) + $quantidade WHERE id=$id;"
	done
	msgok "$(gettext "Ajuste de estoque efetuado")"
	return 0
}

function conciliar_estoque() {
	local query

	if yesno 17 11 "$(gettext "Confirma a atualização?")"; then
		msgok "$(gettext "Aguarde... Atualizando estoque")" "$yellow"
		if sqlite3 "$database" "UPDATE produtos SET estoque = 0;"; then
			query="UPDATE produtos
				SET estoque = estoque + (
			    SELECT IFNULL(SUM(quantidade), 0)
			    FROM compras
			    WHERE produtos.id = compras.id
			);"
			sqlite3 "$database" "$query"
			query="UPDATE produtos
				SET estoque = estoque - (
				SELECT IFNULL(SUM(quantidade), 0)
				FROM vendas
				WHERE produtos.id = vendas.id
			);"
			sqlite3 "$database" "$query"
			mensagem "${xtitle}" "$(gettext "Atualização concluída")"
		else
			mensagem "${xtitle}" "$(gettext "Erro durante a atualização")"
		fi
	fi
}

function soma_teste() {
	sqlite3 "$database" "SELECT produtos.nome, SUM(compras.quantidade) AS total_compras
	FROM produtos
	LEFT JOIN compras ON produtos.id = compras.id
	GROUP BY produtos.nome;"

	sqlite3 "$database" "SELECT p.nome,
                            SUM(c.quantidade) AS total_compras,
                            SUM(v.quantidade) AS total_vendas
                    FROM produtos AS p
                    LEFT JOIN (SELECT id, SUM(quantidade) AS quantidade
                               FROM compras GROUP BY id) AS c ON p.id = c.id
                    LEFT JOIN (SELECT id, SUM(quantidade) AS quantidade
                               FROM vendas GROUP BY id) AS v ON p.id = v.id
                    GROUP BY p.nome;"
}

function sh_criar_tabelas() {
	msgok "$(gettext "Checando tabela produtos")" "" 0
	criar_tabela_produtos
	msgok "$(gettext "Checando tabela fornecedor")" "" 0
	criar_tabela_fornecedor
	msgok "$(gettext "Checando tabela vendas")" "" 0
	criar_tabela_vendas
	msgok "$(gettext "Checando tabela compras")" "" 0
	criar_tabela_compras
}

function sh_drop_table::produtos() {
	if yesno 17 11 "$(gettext "CUIDADO! Procedimento irá apagar todos os registros da tabela produtos. Confirma ?")"; then
		msgerror "$(gettext "Aguarde, Droping tabela produtos")"
		sqlite3 "$database" "DROP TABLE produtos;"
	fi
	sh_criar_tabelas
}

function sh_drop_table::fornecedor() {
	if yesno 17 11 "$(gettext "CUIDADO! Procedimento irá apagar todos os registros da tabela fornecedor. Confirma ?")"; then
		msgerror "$(gettext "Aguarde, Droping tabela fornecedor")"
		sqlite3 "$database" "DROP TABLE fornecedor;"
	fi
	sh_criar_tabelas
}

function sh_drop_table::vendas() {
	if yesno 17 11 "$(gettext "CUIDADO! Procedimento irá apagar todos os registros da tabela vendas. Confirma ?")"; then
		msgerror "$(gettext "Aguarde, Droping tabela vendas")"
		sqlite3 "$database" "DROP TABLE vendas;"
	fi
	sh_criar_tabelas
}

function sh_drop_table::compras() {
	if yesno 17 11 "$(gettext "CUIDADO! Procedimento irá apagar todos os registros da tabela compras. Confirma ?")"; then
		msgerror "$(gettext "Aguarde, Droping tabela compras")"
		sqlite3 "$database" "DROP TABLE compras;"
	fi
	sh_criar_tabelas
}

function sh_show_tabelas() {
	sqlite3 "$database" "SELECT * FROM produtos;"
	sqlite3 "$database" "SELECT * FROM fornecedor;"
	sqlite3 "$database" "SELECT * FROM vendas;"
	sqlite3 "$database" "SELECT * FROM compras;"
	inkey 10
}

function populate_databases() {
	if yesno 17 11 "$(gettext "CUIDADO! Procedimento irá inserir dados aleatórios para testes nas tabelas. Confirma ?")"; then
		sh_fundo
		msgok "$(gettext "Aguarde, populando banco de dados...")"
		populate_database_produtos
		populate_database_fornecedor
		populate_database_vendas
		populate_database_compras
		msgok "$(gettext "Banco de dados populado com sucesso!")"
	fi
}

function populate_database_produtos() {
	local i
	local nome un estoque qmin preco_cents preco codebar validade
	local fabricante=1
	local data
	local values

	msgok "$(gettext "Populando tabela produtos")"
	data="$(sh_date)" # mesma data para todos os registros, calculada uma única vez

	values=""
	for ((i = 1; i <= 100; i++)); do
		nome="Produto $i"
		un="UN"
		estoque=$((RANDOM % 1000))       # Estoque aleatório entre 0 e 999
		qmin=$((RANDOM % 100))           # Quantidade minima aleatório entre 0 e 99
		preco_cents=$((RANDOM % 10000))  # Preço aleatório entre 0.00 e 99.99
		printf -v preco '%d.%02d' $((preco_cents / 100)) $((preco_cents % 100))
		printf -v codebar '%013d' "$i" # Gere um código de barras simples
		sh_random_date
		validade="$RANDOM_DATE_RESULT"

		if [[ $((i % 5)) -eq 0 ]]; then # a cada 5 registros manter o fabricante
			fabricante="$((fabricante + 1))"
		fi

		[[ -n "$values" ]] && values+=","
		values+="('$nome', '$un', $estoque, $preco, '$codebar', '$data', '$validade', '$qmin', '$fabricante')"
	done

	sqlite3 "$database" "INSERT INTO produtos (nome, un, estoque, preco, codebar, data, validade, qmin, fabricante) VALUES $values;"
}

function populate_database_fornecedor() {
	local i
	local data nome ende cida uf cnpj
	local values

	msgok "$(gettext "Populando tabela fornecedor")"
	data="$(sh_date)"

	values=""
	for ((i = 1; i <= 99; i++)); do
		nome="FORNECEDOR $i LTDA"
		ende="ENDERECO$i"
		cida="CIDADE$i"
		printf -v uf '%02d' "$i"
		printf -v cnpj '%02d.%03d.%03d/%04d-%02d' "$i" "$i" "$i" "$i" "$i"

		[[ -n "$values" ]] && values+=","
		values+="('$data', '$nome', '$ende', '$cida', '$uf', '$cnpj')"
	done

	sqlite3 "$database" "INSERT INTO fornecedor (data, nome, ende, cida, uf, cnpj) VALUES $values;"
}

function populate_database_vendas() {
	local i
	local dia mes ano
	local data quantidade preco_cents preco total_cents total docnr id
	local docnr_atual
	local values

	msgok "$(gettext "Populando tabela vendas")"
	# Inicialize o dia, mês e ano
	dia=1
	mes=1
	ano="$(date +"%Y")"

	# Número de documento inicial (uma única consulta, depois só incrementa em bash)
	docnr_atual=$(sqlite3 "$database" "SELECT COALESCE(MAX(docnr), 0) FROM vendas;")
	docnr_atual=$((10#$docnr_atual))

	values=""
	# Loop para inserir 365 registros
	for ((i = 1; i <= 365; i++)); do
		printf -v data '%04d-%02d-%02d' "$ano" "$mes" "$dia" # Construir a data no formato 'AAAA-MM-DD'
		quantidade=$((RANDOM % 10 + 1))                      # Gere uma quantidade aleatória entre 1 e 10
		preco_cents=$RANDOM                                  # Gere um preço aleatório com duas casas decimais
		printf -v preco '%d.%02d' $((preco_cents / 100)) $((preco_cents % 100))
		total_cents=$((quantidade * preco_cents)) # Calcule o total
		printf -v total '%d.%02d' $((total_cents / 100)) $((total_cents % 100))
		((++docnr_atual))
		printf -v docnr '%07d' "$docnr_atual"
		id=$i

		[[ -n "$values" ]] && values+=","
		values+="('$id', '$data', $quantidade, $preco, $total, '$docnr')"

		dia=$((dia + 1))

		# Verificar mês fevereiro
		if [[ $mes -eq 2 && $dia -gt 28 ]]; then
			dia=1
			mes=$((mes + 1))
		fi

		# Verificar se o mês mudou
		if [ $dia -gt 30 ]; then
			dia=1
			mes=$((mes + 1))
			if [[ $mes -gt 12 ]]; then
				mes=1
				ano=$((ano + 1))
			fi
		fi
	done

	# Inserir todos os registros de uma vez na tabela 'vendas' no banco de dados
	sqlite3 "$database" "INSERT INTO vendas (id, data, quantidade, preco, total, docnr) VALUES $values;"
}

function populate_database_compras() {
	local i
	local dia mes ano fornecedor
	local data quantidade custo_cents custo total_cents total id docnr
	local docnr_atual
	local values

	# Inicialize dia, mes e ano
	dia=1
	mes="$(date +"%m")"
	mes=$((10#$mes)) # remove zero à esquerda (evita erro de octal em comparações)
	ano="$(date +"%Y")"
	fornecedor=1
	docnr=""

	msgok "$(gettext "Populando tabela compras")"

	# Número de documento inicial (uma única consulta, depois só incrementa em bash)
	docnr_atual=$(sqlite3 "$database" "SELECT COALESCE(MAX(docnr), 0) FROM compras;")
	docnr_atual=$((10#$docnr_atual))

	values=""
	# Loop para inserir 100 registros
	for ((i = 1; i <= 100; i++)); do
		printf -v data '%04d-%02d-%02d' "$ano" "$mes" "$dia" # Construir a data no formato 'AAAA-MM-DD'
		quantidade=$((RANDOM % 10 + 1))                      # Gere uma quantidade aleatória entre 1 e 10
		custo_cents=$RANDOM                                  # Gere um custo aleatório com duas casas decimais
		printf -v custo '%d.%02d' $((custo_cents / 100)) $((custo_cents % 100))
		total_cents=$((quantidade * custo_cents))
		printf -v total '%d.%02d' $((total_cents / 100)) $((total_cents % 100))
		id="$i"

		if [[ $((i % 5)) -eq 0 ]]; then # a cada 5 registros manter o docnr e fornecedor
			((++docnr_atual))
			printf -v docnr '%07d' "$docnr_atual"
			fornecedor="$((fornecedor + 1))"
		fi

		[[ -n "$values" ]] && values+=","
		values+="('$id', '$fornecedor', '$data', '$docnr', '$quantidade', '$custo', '$total')"

		dia=$((dia + 1))

		# Verificar mês fevereiro
		if [[ $mes -eq 2 && $dia -gt 28 ]]; then
			dia=1
			mes=$((mes + 1))
		fi

		# Verificar se o mês mudou
		if [ $dia -gt 30 ]; then
			dia=1
			mes=$((mes + 1))
			if [[ $mes -gt 12 ]]; then
				mes=1
				ano=$((ano + 1))
			fi
		fi
	done

	# Inserir todos os registros de uma vez na tabela 'compras' no banco de dados
	sqlite3 "$database" "INSERT INTO compras (id, fornecedor, data, docnr, quantidade, custo, total) VALUES $values;"
}

find_max_length() {
	local array=("$@")
	local length
	local max_length=0
	local item

	for item in "${array[@]}"; do
		length=${#item}
		if [ "$length" -gt "$max_length" ]; then
			max_length="$length"
		fi
	done
	echo "$max_length"
}

function show_menu() {
	local linha=$1
	local coluna=$2
	local titulo="$3"
	local itens=("${@:4}")
	local tamanho_maximo=${#titulo}
	local quantidade_itens="${#itens[@]}"
	local i tecla item_formatado
	# Permite abrir já com um item pré-selecionado: o chamador define
	# SHOW_MENU_INDICE_INICIAL antes de chamar show_menu(). Se não for
	# definida, começa no primeiro item (0), igual sempre foi.
	local selecionado="${SHOW_MENU_INDICE_INICIAL:-0}"
	SHOW_MENU_INDICE_INICIAL=
	local sair_do_menu=false
	local color="${Acores[box]}"
	local item
	local t1 t2 t3

	# Calcular o tamanho máximo diretamente no loop
	for item in "${itens[@]}"; do
		((tamanho_maximo = tamanho_maximo < ${#item} ? ${#item} : tamanho_maximo))
	done
	((quantidade_itens > 9)) && ((++tamanho_maximo))

	# Chamar a função 'box' uma vez fora do loop
	box "$linha" "$coluna" "$((quantidade_itens + 2))" "$((tamanho_maximo + 5))" "${titulo}" "${color}"

	while ! $sair_do_menu; do
		for i in "${!itens[@]}"; do
			#			tput cup $((linha + i + 1)) $((coluna + 1))
			printf "\e[%s;%sH" $((linha + i + 2)) $((coluna + 2))
			local item="${itens[i]}"
			local padding=$((tamanho_maximo - ${#item}))
			((i > 8)) && ((--padding))
			[[ -n "${aCorItemMenu[i]}" ]] && color="${aCorItemMenu[i]}"

			if [[ $i -eq $selecionado ]]; then
				item_formatado="${reverse}${color}$((i + 1)). ${item^^}%${padding}s${reset}"
			else
				item_formatado="${color}$((i + 1)). ${item^}%${padding}s${reset}"
			fi
			printf "$item_formatado$reset" ""
		done

      read -rsn1 tecla
      case "$tecla" in
        $'\e')
          if read -rsn1 -t 0.01 t1 && [[ $t1 == "[" ]]; then
            read -rsn1 t2
            case "$t2" in
              A)  # UP (circular)
                ((selecionado = selecionado > 0 ? selecionado - 1 : quantidade_itens - 1))
                ;;
              B)  # DOWN (circular)
                ((selecionado = selecionado < quantidade_itens - 1 ? selecionado + 1 : 0))
                ;;
              5)  # PG_UP  -> ESC [ 5 ~  (circular)
                read -rsn1 t3
                [[ $t3 == "~" ]] && {
                  if (( selecionado == 0 )); then
                    selecionado=$((quantidade_itens - 1))
                  else
                    selecionado=0
                  fi
                }
                ;;
              6)  # PG_DOWN -> ESC [ 6 ~ (circular)
                read -rsn1 t3
                [[ $t3 == "~" ]] && {
                  if (( selecionado == quantidade_itens - 1 )); then
                    selecionado=0
                  else
                    selecionado=$((quantidade_itens - 1))
                  fi
                }
                ;;
            esac
          else
            while read -rsn1 -t 0.01; do :; done
            return 0
          fi
          ;;
        ""|$'\n'|$'\r')
          return $((selecionado + 1))   # ENTER (1-based)
          ;;
      esac
	done
}

function show_menu_pulldown() {
	local linha=$1
	local coluna=$2
	local titulo="$3"
	local itens=("${@:4}")
	local tamanho_titulo=${#titulo}
	local quantidade_itens="${#itens[@]}"
	local tamanho_maximo=$tamanho_titulo
	local i
	local tecla
	local item_formatado
	local sair_do_menu=false
	local color="${Acores[box]}"
	local valor item str
	local npos
	local nItensSubMenu
	local tamanho2_maximo
	local item2
	local item2_formatado
	local x
	local -a campos

	# Calcular o tamanho máximo diretamente no loop (sem fork por item)
	for valor in "${itens[@]}"; do
		item="${valor%%|*}"
		str+="$item "
		((tamanho_maximo = ${#item} > tamanho_maximo ? ${#item} : tamanho_maximo))
	done

	((tamanho_maximo += 2)) # Adiciona 2 espaços entre os itens
	((tamanho_maximo = tamanho_maximo < tamanho_titulo ? tamanho_titulo : tamanho_maximo))

	nTop=$((linha + 1))
	nLeft=1
	#	nMaxItens=$((quantidade_itens + 2))
	#	nRight=$((tamanho_maximo + 2))
	((--pselecionadoV))
	((--pselecionadoH))

	# Iterar sobre os itens novamente para destacar o item selecionado em reverso
	while ! $sair_do_menu; do
		sh_fundo
		printf "${color}\e[%s;%sH%${lastcol}s" $nTop $coluna ""
		npos=1

		for i in "${!itens[@]}"; do
			local str="${itens[i]}"
			IFS='|' read -r -a campos <<<"$str"
			local item="${campos[0]}"
			local padding="${#item}"
			[[ -n "${aCorItemMenu[i]}" ]] && color="${aCorItemMenu[i]}"

			if [[ $i -eq $pselecionadoH ]]; then
				# Formato do item selecionado no menu principal
				item_formatado="${reverse}${color}${item^}${reset}"
				nLeft="$((npos - 1))"
				nItensSubMenu="${#campos[@]}"
				local -a subitens=("${campos[@]:1}")
				tamanho2_maximo=0

				for item2 in "${subitens[@]}"; do
					((tamanho2_maximo = ${#item2} > tamanho2_maximo ? ${#item2} : tamanho2_maximo))
				done

				((tamanho2_maximo = tamanho2_maximo < padding ? padding : tamanho2_maximo))
				nRight="$((npos + tamanho2_maximo - nLeft + 1))"
				box "$nTop" "$nLeft" "$((nItensSubMenu + 1))" "$nRight" "" "$color"

				for x in "${!subitens[@]}"; do
					#					printf "\e[%s;%sH" $((linha + x + 3)) $((coluna + npos +1 ))
					local item2="${subitens[x]}"
					local padding2=$((tamanho2_maximo - ${#item2}))
					[[ -n "${aCorItemMenu[i]}" ]] && color="${aCorItemMenu[x]}"

					if [[ $x -eq $pselecionadoV ]]; then
						item2_formatado="${reverse}${color}${item2^}%${padding2}s${reset}"
					else
						item2_formatado="${color}${item2^}%${padding2}s${reset}"
					fi
					printf "\e[%s;%sH${item2_formatado}${rst}" $((linha + x + 3)) $((coluna + npos + 1))
				done
			else
				item_formatado="${color}${item^}${reset}"
			fi
			printf "\e[$((linha + 1));%sH${item_formatado}${rst}" "$npos"
			npos=$((npos + padding + 1))
		done
		read_key
		case "$LAST_KEY" in
		"$K_UP")
			((pselecionadoV = pselecionadoV > 0 ? pselecionadoV - 1 : nItensSubMenu - 2))
			;;

		"$K_DOWN")
			((pselecionadoV = pselecionadoV < nItensSubMenu - 2 ? pselecionadoV + 1 : 0))
			;;

		"$K_LEFT")
			pselecionadoV=0
			((pselecionadoH = pselecionadoH > 0 ? pselecionadoH - 1 : quantidade_itens - 1))
			;;

		"$K_RIGHT")
			pselecionadoV=0
			((pselecionadoH = pselecionadoH < quantidade_itens - 1 ? pselecionadoH + 1 : 0))
			;;

		"$K_ENTER")
			((++pselecionadoV))
			((++pselecionadoH))
			return "${pselecionadoH}${pselecionadoV}"
			;;

		"$K_ESC")
			return 1
			;;
		esac
	done
}

function menu_fornecedores() {
	local xtitle="$(gettext "MENU FORNECEDORES")"
	local opcao
	local options=(
		"$Cadastrar"
		"$Alterar"
		"$Remover_Excluir"
		"$Pesquisar"
		"$Voltar"
	)

	while true; do
		tela
		titulo 1 "$xtitle" "${Acores[statussup]}"
		show_menu 11 10 "$xtitle" "${options[@]}"
		opcao="$?"

		case "$opcao" in
		1) fornecedor_inclusao ;;
		2) fornecedor_alteracao ;;
		3) fornecedor_exclusao ;;
		4) fornecedor_pesquisa ;;
		*) return ;;
		esac
	done
}

function menu_produtos() {
	local xtitle="$(gettext "MENU PRODUTOS")"
	local opcao
	local options=(
		"$Cadastrar"
		"$Alterar"
		"$Remover_Excluir"
		"$Pesquisar"
		"$Voltar"
	)

	while true; do
		tela
		titulo 1 "$xtitle" "${Acores[statussup]}"
		show_menu 11 10 "$xtitle" "${options[@]}"
		opcao="$?"

		case "$opcao" in
		1) produto_inclusao_alteracao 'I' ;;
		2) produto_inclusao_alteracao 'A' ;;
		3) produto_exclusao ;;
		4) produto_pesquisa ;;
		*) return ;;
		esac
	done
}

function menu_manutencao() {
	local xtitle="$(gettext "MENU MANUTENÇÃO")"
	local opcao
	local options=(
		"$(gettext 'Atualizar Estoque (conciliação)')"
		"$(gettext 'Popular DataBases para testes')"
		"$(gettext 'Zerar/Limpar DataBase Produtos')"
		"$(gettext 'Zerar/Limpar DataBase Fornecedor')"
		"$(gettext 'Zerar/Limpar DataBase Vendas')"
		"$(gettext 'Zerar/Limpar DataBase Compras')"
		"$Voltar"
	)

	while true; do
		tela
		titulo 1 "$xtitle" "${Acores[statussup]}"
		show_menu 11 10 "$xtitle" "${options[@]}"
		opcao="$?"

		case "$opcao" in
		1) conciliar_estoque ;;
		2) populate_databases ;;
		3) sh_drop_table::produtos ;;
		4) sh_drop_table::fornecedor ;;
		5) sh_drop_table::vendas ;;
		6) sh_drop_table::compras ;;
		*) return ;;
		esac
	done
}

function menu_relatorios() {
	local xtitle="$(gettext "MENU PEQUISA/RELATÓRIOS/CONSULTA")"
	local opcao
	local options=(
		"$Produtos"
		"$Produtos_Vendidos"
		"$Entradas_de_Produtos"
		"$Produtos_abaixo_estoque_minimo"
		"$Produtos_fora_da_validade"
		"$Vendas_Diarias"
		"$Fornecedores"
		"$Voltar"
	)

	while true; do
		tela
		titulo 1 "$xtitle" "${Acores[statussup]}"
		show_menu 11 10 "$xtitle" "${options[@]}"
		opcao="$?"

		case "$opcao" in
		1) produto_pesquisa ;;
		2) relatorio_produtos_vendidos ;;
		3) relatorio_entradas_produtos ;;
		4) relatorio_produtos_minimo ;;
		5) relatorio_produtos_fora_validade ;;
		6) relatorio_vendas_diarias ;;
		7) fornecedor_pesquisa ;;
		*) return ;;
		esac
	done
}

function configuracao::dados_empresa() {
	local xtitle="$(gettext "DADOS DA EMPRESA")"
	local data_dia="$(sh_date)"
	local half_lastcol=$(($(lastcol) / 2))
	local razao ende cida uf cnpj

	tela
	titulo 1 "$xtitle" "${Acores[statussup]}"
	box 11 10 7 "$half_lastcol" "$xtitle" "${Acores[box]}"
	print 12 11 "$(gettext "Nome")                 : "
	print 13 11 "$(gettext "Endereço")             : "
	print 14 11 "$(gettext "Cidade")               : "
	print 15 11 "$(gettext "UF")                   : "
	print 16 11 "$(gettext "Cnpj")                 : "

	while :; do
		get 12 11 "$(gettext "Nome")                 : " razao "${Aempresa[razao]}" || return
		if [[ -n "$razao" ]]; then
			break
		else
			setpos 18 10
			if readconf "$(gettext "O Nome não pode ser em branco. Cancelar?")"; then
				return
			fi
		fi
	done

	get 13 11 "$(gettext "Endereço")             : " ende "${Aempresa[ende]}" || return
	get 14 11 "$(gettext "Cidade")               : " cida "${Aempresa[cida]}" || return
	get 15 11 "$(gettext "UF")                   : " uf "${Aempresa[uf]}" || return
	get 16 11 "$(gettext "Cnpj")                 : " cnpj "${Aempresa[cnpj]}" || return

	if yesno 18 10 "$(gettext "Confirma dados?")"; then
		Aempresa[razao]="$razao"
		Aempresa[ende]="$ende"
		Aempresa[cida]="$cida"
		Aempresa[uf]="$uf"
		Aempresa[cnpj]="$cnpj"
		TIni.Set "$INI_FILE" "empresa" "razao" "$razao"
		TIni.Set "$INI_FILE" "empresa" "ende" "$ende"
		TIni.Set "$INI_FILE" "empresa" "cida" "$cida"
		TIni.Set "$INI_FILE" "empresa" "uf" "$uf"
		TIni.Set "$INI_FILE" "empresa" "cnpj" "$cnpj"
		msgok "$Registro_efetuado_com_sucesso"
	else
		msgerror "$(gettext "Inclusão/alteração não efetuada.")"
	fi
}

function configuracao::cores() {
	local type="$1"
	local ctitulo="$2"
	local xtitle="$(gettext "CONFIGURAÇÃO DE CORES")"
	local atype=('logo' 'cabecalho' 'statussup' 'statusinf' 'box' 'boxtitle' 'dispbox' 'msgok' 'msgerror' 'conf' 'corpanofundo')
	local ctype="${atype[$type]}"
	local sair_do_menu=false
	local selecionado
	local tecla
	local restante
	local color
	local cor_escolhida

	# Inicia na cor já configurada (do .ini, ou o padrão do sistema se não
	# houver .ini/valor salvo - Acores[$ctype] já reflete isso).
	selecionado="$(ansi_extrair_cor "${Acores[$ctype]}")"
	if [[ -z "$selecionado" || "$selecionado" -lt 1 || "$selecionado" -gt 255 ]]; then
		selecionado=1
	fi

	tela
	while ! $sair_do_menu; do
		if ((selecionado > 15)); then
			color=$(ansi_setab $selecionado)
		else
			color=$(ansi_setaf $selecionado)
		fi
		printf '\e(B\e[m'
		titulo 1 "$xtitle - $ctitulo" "${Acores[statussup]}"
		box 11 10 9 60 "$xtitle - $ctitulo" "$color"
		print 13 12 "$(gettext "COR SELECIONADA :") $selecionado/255" "$color"
		print 14 12 "$(gettext "ESC             : CANCELAR")" "$color"
		print 15 12 "$(gettext "ENTER           : ACEITAR ESCOLHA")" "$color"
		print 16 12 "$(gettext "SETA ACIMA  ↑   : ALTERAR COR +")" "$color"
		print 17 12 "$(gettext "SETA ABAIXO ↓   : ALTERAR COR -")" "$color"
		read -s -n 1 tecla

		case $tecla in
		$'\x1b') # Tecla Escape
			read -s -n 2 -t 0.1 restante
			if [[ $restante == "[B" ]]; then
				selecionado=$((selecionado > 1 ? selecionado - 1 : 255))
			elif [[ $restante == "[A" ]]; then
				selecionado=$((selecionado < 255 ? selecionado + 1 : 1))
			else
				sair_do_menu=true
			fi
			;;
		"")
			if ((selecionado > 15)); then
				cor_escolhida=$(ansi_setab $selecionado)
			else
				cor_escolhida=$(ansi_setaf $selecionado)
			fi
			Acores[$ctype]="$cor_escolhida"
			TIni.Set "$INI_FILE" "cores" "$ctype" "$cor_escolhida"
			break
			;;
		esac
	done
}

function sobre::about() {
	local xtitle="$(gettext 'SOBRE')"
	local itens=15
	local half_lastcol=$(($(lastcol) / 2))
	local nrow=$((($(lastrow) - $itens) / 2))
	local nleft=15

	tela
	titulo 1 "$xtitle" "${Acores[statussup]}"
	box "$nrow" "$nleft" "$itens" "$((lastcol - 30))" "$xtitle" "$white"
	print $((nrow + 1)) $((nleft + 1)) "$(padc "pdvShell v$_VERSION_" "$((lastcol - 22))" ' ')" "$red"
	print $((nrow + 2)) $((nleft + 1)) "$(padc "$_SYSTEM_DESC" "$((lastcol - 22))" ' ')" "$green"
	print $((nrow + 4)) $((nleft + 1)) "$(padc "Copyright © 2023-2023, Jefferson Carneiro <slackjeff>. Todos os direitos reservados." "$((lastcol - 22))" ' ')" "$black"
	print $((nrow + 5)) $((nleft + 1)) "$(padc "https://github.com/slackjeff/pdvShell" "$((lastcol - 22))" ' ')" "$black"
	print $((nrow + 6)) $((nleft + 1)) "$(padc "Copyright © 2023-2026, Vilmar Catafesta <vcatafesta@gmail.com>. Todos os direitos reservados." "$((lastcol - 22))" ' ')" "$black"
	print $((nrow + 7)) $((nleft + 1)) "$(padc "https://github.com/vcatafesta/pdvShell" "$((lastcol - 22))" ' ')" "$black"
	print $((nrow + 9)) $((nleft + 1)) "$(padc "$(gettext "O pdvShell é disponibilizado para você sob a Licença MIT, e")" "$((lastcol - 22))" ' ')" "$white"
	print $((nrow + 10)) $((nleft + 1)) "$(padc "$(gettext "inclui software de código aberto sob uma variedade de outras licenças.")" "$((lastcol - 22))" ' ')" "$white"
	print $((nrow + 11)) $((nleft + 1)) "$(padc "$(gettext "Você pode ler instruções sobre como baixar e criar para você mesmo")" "$((lastcol - 22))" ' ')" "$white"
	print $((nrow + 12)) $((nleft + 1)) "$(padc "$(gettext "o código fonte específico usado para criar esta cópia.")" "$((lastcol - 22))" ' ')" "$white"
	print $((nrow + 13)) $((nleft + 1)) "$(padc "$(gettext "Este programa vem com absolutamente nenhuma garantia.")" "$((lastcol - 22))" ' ')" "$white"
	msgok "" "" -1
}

function configuracao::pano_de_fundo() {
	local xtitle="$(gettext "PANO DE FUNDO")"
	local opcao
	local panofundo
	local nLenOptions=0
	local options=(
		"░░░▒▒▒▒▒▒▒░░░░░░░░▒▒▒▒▒▒▒"
		"$(printf "\u2591\u2592\u2593")"
		"▓▒▓░▒░▒"
		"░▒▓"
		"▓░"
		"░"
		"▒"
		"▓"
		"█▓░▒pdvShell█▒▓░"
		"┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼"
		"└┐█▄▀└┐└┐█▄▀"
		"░░░░░▒▒▒▒▒░░░░░▓"
		"=-"
		":-"
		"%%"
		"##"
		"@@"
		"' '"
		"pdvShell"
		"$Voltar"
	)

	nLenOptions=${#options[@]}
	while true; do
		tela
		titulo 1 "$xtitle" "${Acores[statussup]}"

		# Abre já com o padrão de fundo atualmente ativo pré-selecionado
		local i indice_inicial=0
		for i in "${!options[@]}"; do
			if [[ "${options[i]}" == "${Acores[panofundo]}" ]]; then
				indice_inicial=$i
				break
			fi
		done
		SHOW_MENU_INDICE_INICIAL="$indice_inicial"

		show_menu 05 10 "$xtitle" "${options[@]}"
		opcao="$?"

		case "$opcao" in
		$nLenOptions | 0) return ;;
		*)
			panofundo="${options["$((opcao - 1))"]}"
			TIni.Set "$INI_FILE" "cores" "panofundo" "$panofundo"
			Acores[panofundo]="$panofundo"
			;;
		esac
	done
}

function menu_configuracao() {
	local xtitle="$(gettext "MENU CONFIGURAÇÃO")"
	local opcao
	local options=(
		"$(gettext 'Dados Empresa')"
		"$(gettext 'Cor Logo')"
		"$(gettext 'Cor Cabecalho')"
		"$(gettext 'Cor Status Superior')"
		"$(gettext 'Cor Status Inferior')"
		"$(gettext 'Cor Box')"
		"$(gettext 'Cor Titulo Box')"
		"$(gettext 'Cor DispBox')"
		"$(gettext 'Cor Mensagem Info OK')"
		"$(gettext 'Cor Mensagem Info ERRO')"
		"$(gettext 'Cor Mensagem Confirmação')"
		"$(gettext 'Cor Pano de fundo')"
		"$(gettext 'Pano de fundo')"
		"$Voltar"
	)

	while true; do
		tela
		titulo 1 "$xtitle" "${Acores[statussup]}"
		show_menu 05 10 "$xtitle" "${options[@]}"
		opcao="$?"

		case "$opcao" in
		14 | 0) return ;;
		1) configuracao::dados_empresa ;;
		[2-9] | 1[0-2]) configuracao::cores "$((opcao - 2))" "${options[$((opcao - 1))]}" ;;
		13) configuracao::pano_de_fundo ;;
		*) msgerror "$Opcao_invalida" ;;
		esac
	done
}

function sh_main_menu() {
	local xtitle="${Menu_Principal^^}"
	local half_lastrow=$(($(lastrow) / 2))
	local half_lastcol=$(($(lastcol) / 4))
	local opcao
	declare -a options=(
		"$Sair|$Sair_do_Sistema"
		"$Produtos|$Inclusao|$Alteracao|$Exclusao|$Consulta"
		"$Fornecedores|$Inclusao|$Alteracao|$Exclusao|$Consulta"
		"$Movimento|$Realizar_Venda_Saida|$Entradas_de_Produtos|$Vendas_Diarias"
		"$Relatorios|$Produtos|$Produtos_Vendidos|$Entradas_de_Produtos|$Produtos_abaixo_estoque_minimo|$Produtos_fora_da_validade|$Vendas_Diarias|$Fornecedores"
		"$Consultas|$Produtos|$Produtos_Vendidos|$Entradas_de_Produtos|$Produtos_abaixo_estoque_minimo|$Produtos_fora_da_validade|$Vendas_Diarias|$Fornecedores"
		"$Manutencao|$Atualizar_Estoque|$Popular_Databases|$Zerar_Limpar_Produtos|$Zerar_Limpar_Fornecedor|$Zerar_Limpar_Vendas|$Zerar_Limpar_Compras"
		"$Configuracao|$Dados_Empresa|$Aparencia|$Pano_de_fundo"
		"$Sobre|$Sobre_o pdvShell"
	)

	while true; do
		tela
		show_menu_pulldown 2 0 "$xtitle" "${options[@]}"
		opcao="$?"

		case "$opcao" in
		1 | 11)
			if yesno $((half_lastrow - 6)) $half_lastcol "$(gettext "Pergunta: Deseja realmente Sair?")"; then
				sh_unsetvarcolors
				clear
				exit 0
			fi
			;;
		21) produto_inclusao_alteracao 'I' ;;
		22) produto_inclusao_alteracao 'A' ;;
		23) produto_exclusao ;;
		24) produto_pesquisa ;;
		31) fornecedor_inclusao ;;
		32) fornecedor_alteracao ;;
		33) fornecedor_exclusao ;;
		34) fornecedor_pesquisa ;;
		41) realizar_venda ;;
		42) produtos_entradas ;;
		43) relatorio_vendas_diarias ;;
		51 | 61) produto_pesquisa ;;
		52 | 62) relatorio_produtos_vendidos ;;
		53 | 63) relatorio_entradas_produtos ;;
		54 | 64) relatorio_produtos_minimo ;;
		55 | 65) relatorio_produtos_fora_validade ;;
		56 | 66) relatorio_vendas_diarias ;;
		57 | 67) fornecedor_pesquisa ;;
		71) conciliar_estoque ;;
		72) populate_databases ;;
		73) sh_drop_table::produtos ;;
		74) sh_drop_table::fornecedor ;;
		75) sh_drop_table::vendas ;;
		76) sh_drop_table::compras ;;
		81) configuracao::dados_empresa ;;
		82) menu_configuracao ;;
		83) configuracao::pano_de_fundo ;;
		91) sobre::about ;;
		*) msgerror "$Opcao_invalida" ;;
		esac
	done
}

# END PROCEDURES

#entrypoint
sh_atualizar_tamanho_tela
sh_config
sh_setvarcolors
sh_environment
sh_checkDependencies
sh_criar_tabelas
sobre::about
sh_main_menu
#end

: '
################################################################################
CHANGELOG - revisão e otimização (ago/2026)
################################################################################

[ter 11 ago 2026 ~16:47-17:05] CORREÇÕES INICIAIS DE BUGS
------------------------------------------------------------------------
- Corrigido "$Configuracao|Dados_Empresa|..." no menu principal: faltava
  o "$" antes de Dados_Empresa (aparecia texto literal em vez do label
  traduzido).
- Corrigido "ntop" vs "nTop" em relatorio_vendas_diarias (variável errada
  jogava a linha de SOMA sempre na mesma posição fixa, ignorando nTop).
- Corrigido "tamanho_maxino" vs "tamanho_maximo" em show_menu (variável
  declarada com nome errado vazava como global entre chamadas).
- Corrigido "${_SYSTEM}" vs "${_SYSTEM_}" em mensagem()/registrar_venda/
  atualizar_estoque_vendas (variável inexistente, título sempre vazio).
- Adicionado "local" em dezenas de variáveis que vazavam para o escopo
  global em ~25 funções (produto_pesquisa, relatorio_produtos_minimo,
  relatorio_produtos_fora_validade, relatorio_produtos_vendidos,
  fornecedor_pesquisa, relatorio_vendas_diarias, realizar_venda,
  produtos_entradas, padr/padl/padc, sh_splitarray, convert_date_to_US,
  validar_data, populate_database_*, yesno, show_menu,
  show_menu_pulldown, debug, atualizar_estoque_vendas, TIni.ExistValue/
  ReadValue/Set, inkey, relatorio_vendas_diarias (dead code removido)).
- sql_escape(): escapa aspas simples antes de montar queries SQL,
  aplicada em dbseek() e nos INSERT/UPDATE de produto e fornecedor -
  previne quebra de query e injeção SQL via nomes com apóstrofo.
- Corrigido bug de dados duplicados/sobrescritos em fornecedor_inclusao():
  variáveis de um cadastro anterior não eram resetadas no loop, causando
  sobrescrita do fornecedor anterior ao invés de criar um novo.

[ter 11 ago 2026 ~17:05-18:00] CNPJ/CPF, ALERTA() E PADRONIZAÇÃO DE DIÁLOGOS
------------------------------------------------------------------------
- fornecedor_selecionar(): tela de seleção de fornecedor cadastrado
  (navegação com setas), acionada quando o campo Fabricante fica em
  branco ou quando o código digitado não é encontrado.
- validar_cnpj_cpf(): validação de CPF/CNPJ com dígito verificador real
  (algoritmo oficial, módulo 11), rejeitando sequências óbvias tipo
  000.000.000-00.
- formatar_cnpj_cpf(): aplica a máscara oficial (00.000.000/0000-00
  para CNPJ, 000.000.000-00 para CPF) automaticamente ao salvar.
- Rótulo "Cnpj" alterado para "CNPJ/CPF" nas telas de fornecedor.
- Perguntas de confirmação (readconf) convertidas para yesno() nos
  cadastros de produto e fornecedor, padronizando a interface.
- Corrigida checagem de fornecedor duplicado que não pegava reincidência
  ao reenviar o mesmo nome (comparação trocada de LIKE para exata).
- alerta(): caixa de diálogo estilo "dialog --msgbox" (mensagem e botão
  [ OK ] centralizados), substituindo o antigo msgerror/msgok (barra no
  topo com timeout curto) nos formulários de cadastro. Passou por várias
  iterações nesta rodada até chegar no formato final centralizado.

[ter 11 ago 2026 ~18:00-21:05] TELA, FORMULÁRIOS E NAVEGAÇÃO
------------------------------------------------------------------------
- Corrigido bug visual em get(): texto de uma tentativa anterior ficava
  "fantasma" na tela mesmo com o campo logicamente vazio, levando o
  usuário a crer que o valor antigo ainda estava lá.
- Corrigido campo de formulário vazando para fora da caixa (get() usava
  tput el, que limpa até o fim físico da linha do terminal) - adicionado
  parâmetro de largura opcional.
- Corrigido ESC não saindo de formulários (fornecedor/produto) em vários
  campos - adicionado "|| return" nas chamadas de get().
- Corrigida "faixa preta" ao fechar diálogos (alerta()/yesno()): a
  repintura usava tput sgr0 + apagar, sobrescrevendo o padrão de fundo
  customizado do sistema com o preto padrão do terminal - corrigido
  repintando com o mesmo padrão de fundo do sistema.
- yesno(): mesma limpeza de tela do alerta() ao fechar (Sim, Não ou ESC).
- Campo Unidade do cadastro de produtos: validação de exatamente 2
  caracteres (ex: KG, UN, PC), com limite de digitação e uppercase
  automático.
- dbcount(): função genérica para contar registros de uma tabela
  (dbcount "$database" "tabela"), usada nas checagens de fornecedor
  cadastrado.
- Campo Fabricante do cadastro de produtos: em branco vai direto para a
  tela de seleção de fornecedores; código não encontrado pergunta se
  quer escolher da lista - mesma tela de seleção.

[qua 12 ago 2026 ~00:05-01:10] CORREÇÃO DO FLUXO DE SELEÇÃO DE FORNECEDOR
------------------------------------------------------------------------
- Corrigido fornecedor_selecionar() sendo chamada via $(...): isso
  capturava TODA a renderização de tela (tela/titulo/show_menu) dentro da
  variável em vez de mostrar na tela real. Corrigido usando variável
  global (FORNECEDOR_SELECIONADO_ID) em vez de echo + command
  substitution - mesmo padrão usado em read_key()/LAST_KEY.
- Corrigido alerta()/show_menu() "comendo" a sequência de teclas de setas
  e exigindo dois ENTERs (dreno de teclado mal posicionado quebrava
  sequências rápidas de múltiplos bytes, como setas do teclado) -
  removido dos dois lugares.
- Corrigido erro de octal do bash: números com zero à esquerda ("08",
  "09") em contexto aritmético ((...))/[[ -eq ]] quebravam com "valor
  muito grande para esta base de numeração". Corrigido em validar_data(),
  populate_database_compras() e no campo Quantidade de vendas/entradas.

[qua 12 ago 2026 ~15:20-16:05] OTIMIZAÇÃO DE PERFORMANCE E BUGS DO .INI
------------------------------------------------------------------------
- Cache de dimensões do terminal (_LASTROW_CACHE_/_LASTCOL_CACHE_):
  lastrow()/lastcol() não disparam mais "tput lines"/"tput cols" a cada
  chamada (eram usadas em 63 pontos do script). Atualizado uma vez no
  início e via trap em SIGWINCH se o terminal for redimensionado.
- tela()/titulo()/sh_fundo(): tput sc/sgr0/rc trocados por sequências
  ANSI literais (\e[s, \e[0m, \e[u); $(date) trocado por printf nativo
  do bash (%()T); ~20 processos por chamada reduzidos a ~1.
- box()/mabox(): eliminados os forks de replicate() dentro do loop de
  desenho das laterais - linha do meio calculada uma vez e reutilizada
  em vez de recalculada a cada linha de altura da caixa.
- show_menu_pulldown() (menu principal, redesenha a cada tecla): forks
  de sh_splitarray()/len_split_str() eliminados via split nativo do bash
  (IFS read -a), sem subshell.
- read_key(): retorno trocado de echo+$(...) para variável global
  (LAST_KEY), eliminando 1 fork por tecla apertada no menu principal.
- populate_database_*(): todos os INSERTs de cada tabela agrupados em um
  único comando sqlite3 (eram até 365 chamadas separadas); bc trocado
  por aritmética inteira em bash; consultas de docnr (antes 1 por linha)
  buscadas uma única vez e incrementadas em bash; sh_random_date()
  reescrita sem shuf/date -d. De ~4590 processos para ~6.
- TIni.Get(): reescrita em bash puro, sem "sed" por chamada (era
  chamada 17 vezes na inicialização, uma por cada dado de empresa/cor).
- dec_mult()/dec_add()/dec_sub(): aritmética decimal (multiplicação,
  soma, subtração) em bash puro, sem "bc". Aplicada em realizar_venda()
  (tela de venda/PDV) e produtos_entradas() (entrada de produtos) -
  eram até 4 processos (bc/tr) por item do carrinho a cada redesenho
  da tela, a mais usada do sistema. Também aplicada em
  relatorio_produtos_vendidos() e relatorio_entradas_produtos()
  (mesmo domínio seguro: quantidade x preço de linha individual).
- relatorio_vendas_diarias(): removidas 4 linhas de código morto
  (mes_inicial/mes_final/ano_inicial/ano_final calculados via
  "date -d" mas nunca usados); extração de mês dentro do loop trocada
  por substring do bash. A soma agregada (SUM() do SQL) foi mantida com
  "bc" propositalmente, por poder ter mais de 2 casas decimais.
- ansi_setaf()/ansi_setab(): geram as sequências ANSI de cor (256 cores)
  equivalentes a "tput setaf/setab N" em bash puro, sem processo
  externo. Aplicado em sh_setvarcolors() (paleta de cores na
  inicialização) e em configuracao::cores() (tela de escolha de cor,
  redesenha a cada tecla apertada ao navegar pelas 255 cores).
- ansi_extrair_cor(): extrai o número da cor (0-255) de uma sequência
  ANSI já montada, mesmo composta com outros códigos (bold, reverse).
  Usada em configuracao::cores() para a tela de seleção de cor abrir já
  posicionada na cor atualmente configurada (do .ini, ou o padrão do
  sistema quando não há valor salvo), em vez de sempre começar fixo na
  cor 1.
- show_menu(): adicionado suporte a item inicial pré-selecionado via
  variável SHOW_MENU_INDICE_INICIAL (opcional, não afeta os outros ~7
  chamadores que não a definem). Aplicado em
  configuracao::pano_de_fundo(): a tela de escolha do padrão de fundo
  agora também abre já posicionada no padrão atualmente ativo.
- TIni.Set() - bug 1: na atualização de uma chave já existente, o valor
  era inserido direto no comando "sed -i" sem escapar caracteres com
  significado especial na substituição do sed - um valor contendo "&"
  (ex: razão social "Bar & Mercearia") era corrompido, pois o sed
  interpreta & como "insira o texto que casou aqui". Corrigido
  escapando barra invertida, & e o delimitador | antes de montar o
  comando sed.
- TIni.Set() - bug 2, mais grave: a variável found_section nunca voltava
  a 0 ao passar por uma seção DIFERENTE da procurada durante a varredura
  do arquivo. Resultado: ao gravar uma chave nova numa seção que já
  existe mas não é a última do arquivo, a chave nova era silenciosamente
  anexada no final do arquivo, ficando visualmente dentro da seção
  ERRADA - o dado ficava ilegível para TIni.Get(). Corrigido resetando
  found_section=0 ao encontrar qualquer outro cabeçalho de seção.

[qua 12 ago 2026 16:12] PANO DE FUNDO E FORMATO DO CHANGELOG
------------------------------------------------------------------------
- configuracao::pano_de_fundo(): mesmo princípio aplicado às cores -
  a tela agora abre já posicionada no padrão de fundo atualmente ativo
  (do .ini, ou o padrão do sistema), em vez de sempre começar no
  primeiro item da lista. Usa o novo suporte de item inicial do
  show_menu() (SHOW_MENU_INDICE_INICIAL).
- Changelog reorganizado em blocos datados (esta rodada em diante,
  cada bloco mostra a data/hora real em que aquele grupo de mudanças
  foi feito, reconstruída a partir do cabeçalho Updated: atualizado a
  cada rodada ao longo da conversa).

[qua 12 ago 2026 22:46-22:47] AJUSTES DE TEXTO/CABEÇALHO
------------------------------------------------------------------------
- Ordem das linhas de copyright invertida (Vilmar Catafesta primeiro,
  Jefferson Carneiro depois) e espaçamento padronizado.
- Descrição do cabeçalho do arquivo traduzida para português, batendo
  com o texto já usado em _SYSTEM_DESC.
- Item de menu "Cores" renomeado para "Aparência" (rótulo exibido) e a
  variável interna também renomeada de Cores para Aparencia, para não
  ficar inconsistente com o texto que ela guarda.

[qui 13 ago 2026 03:50] TELAS DE RELATÓRIO/CONSULTA RESPONSIVAS
------------------------------------------------------------------------
- Diagnosticado o motivo das telas de relatório/busca quebrarem
  dependendo da resolução do terminal: as larguras de coluna eram
  100% fixas no código (ex: "5|40|2|5|10|5|5|10|13"), sem nenhuma
  relação com o tamanho real do terminal; e a paginação em 2 colunas
  lado a lado nunca verificava se o conteúdo cabia na metade da tela,
  causando sobreposição visual em terminais estreitos (medido: a busca
  de fornecedores precisa de ~147 caracteres, chegando a exigir mais
  de 290 colunas de terminal para a divisão em 2 colunas fazer sentido).
- calcular_larguras(): calcula larguras de coluna ajustadas à largura
  disponível - campos flexíveis (texto livre, como descrição/nome/
  endereço) encolhem proporcionalmente até um mínimo, nunca abaixo
  disso; campos fixos (ID, datas, preços, códigos) nunca mudam. Nunca
  ultrapassa a largura disponível (ajuste fino por arredondamento).
- calcular_colunas_cabiveis(): decide dinamicamente se cabem 2 colunas
  lado a lado (com base na largura MÍNIMA viável da tabela) ou se é
  preciso cair para 1 coluna usando a tela inteira - evita a
  sobreposição na raiz, ao invés de só encolher texto até não caber
  de jeito nenhum.
- Aplicado nas 6 telas com paginação lado a lado: produto_pesquisa,
  relatorio_produtos_minimo, relatorio_produtos_fora_validade,
  fornecedor_pesquisa (3 campos flexíveis: nome/endereço/cidade),
  relatorio_produtos_vendidos, relatorio_entradas_produtos. Também
  aplicado em realizar_venda() e produtos_entradas() (telas de
  carrinho, sem paginação - usam a largura total do terminal como
  alvo, e o separador "├──┤" abaixo da lista é recalculado para
  acompanhar a nova largura da tabela).
- relatorio_vendas_diarias() não foi alterada: a tabela (DATA|TOTAL
  DIA) precisa de só ~22 caracteres e já tinha lógica própria de
  múltiplas colunas dinâmicas: nunca teve o problema de sobreposição.
- As linhas de dados de cada tela foram ajustadas para usar a mesma
  largura calculada do cabeçalho (via "%-*s" do printf, com largura
  passada como argumento), garantindo que as colunas de dados sempre
  alinhem com o cabeçalho, incluindo truncamento do texto quando a
  coluna encolhe.
- Validado com 13 cenários (5 telas x larguras de terminal de 80, 132
  e 300 colunas): nenhum caso ultrapassou a largura disponível, e a
  decisão de 1 ou 2 colunas mudou corretamente conforme o espaço.

[qui 13 ago 2026 04:24] CORREÇÃO: ESPAÇO DESPERDIÇADO NAS TELAS RESPONSIVAS
------------------------------------------------------------------------
- Reportado com print de tela: a busca de fornecedores ficou com a
  caixa ocupando só metade da largura do terminal, texto truncado à
  toa e um espaço preto enorme sobrando à direita, mesmo com poucos
  registros (cabendo tudo numa única página).
- Causa: calcular_colunas_cabiveis() decidia usar 2 colunas lado a
  lado baseado apenas na largura do terminal permitir, sem checar se
  havia dados suficientes para realmente precisar da segunda coluna -
  reservando (e desperdiçando) metade da tela mesmo quando só uma
  página de resultados seria exibida.
- Corrigido removendo a especulação de 2 colunas por completo: as 6
  telas voltam a usar sempre a largura total do terminal para uma
  única coluna, paginando verticalmente ("Página: N, pressione
  qualquer tecla") quando os dados não cabem de uma vez - mais simples
  e sem essa classe de bug. calcular_colunas_cabiveis() foi removida
  do script (não é mais chamada em lugar nenhum). calcular_larguras()
  foi mantida: continua encolhendo colunas de texto livre só quando o
  terminal realmente não tem espaço suficiente.

[qui 13 ago 2026 04:35] BROWSE_TABELA() - NAVEGADOR ESTILO CLIPPER/HARBOUR
------------------------------------------------------------------------
- browse_tabela(): novo widget de navegação de dados tabulares, inspirado
  no Browse()/TBrowse do Clipper/Harbour. Só desenha as linhas realmente
  visíveis na tela (janela de rolagem), então nunca estoura o terminal
  nem desperdiça espaço, não importa quantos registros existam. Suporta
  setas (cima/baixo, move o cursor e rola quando necessário), PgUp/PgDn
  (pula uma tela inteira de cada vez), Home/End (primeiro/último
  registro), Enter (seleciona e devolve a linha via variáveis globais
  BROWSE_SELECIONADO/BROWSE_LINHA_SELECIONADA) e ESC (cancela). Não usa
  show_menu() como base porque essa função desenha TODOS os itens de
  uma vez sem nenhum controle de rolagem - com muitos registros ela
  estouraria o terminal do mesmo jeito.
- fornecedor_pesquisa() reescrita para usar browse_tabela(): a função
  ficou bem mais simples (não precisa mais da lógica manual de
  paginação "Página: N, pressione tecla"), e a navegação ficou muito
  mais fluida - sem mais interrupções a cada tela cheia, rolagem livre
  pra cima/baixo/PgUp/PgDn/Home/End pelo resultado inteiro.
- Validado com 9 cenários de navegação (limites de início/fim, PgUp/
  PgDn, Home/End, seleção com Enter, cancelamento com ESC, array
  vazio) e um teste de integração completo simulando 30 fornecedores,
  em terminal estreito (80 col, larguras encolhem corretamente) e
  largo (155 col, mesmo cenário do print reportado - usa a largura
  ideal completa, sem espaço desperdiçado).
- Corrigido durante o desenvolvimento: a função entrava em loop
  infinito se a leitura de tecla falhasse (ex: entrada esgotada) -
  agora trata isso como equivalente a ESC.

[qui 13 ago 2026 05:22] BROWSE_TABELA() APLICADA NAS 6 TELAS RESTANTES
------------------------------------------------------------------------
- browse_tabela() estendida para suportar cor por linha: uma linha de
  dado pode ter um campo extra no final (ex: "5|Produto|10|$vermelho")
  que é tratado como cor daquela linha específica, sem afetar linhas
  que não usam essa cor - preserva indicadores visuais funcionais (não
  só decorativos) como vermelho/verde para estoque abaixo do mínimo ou
  produto vencido, que se perderiam numa conversão simples.
- Convertidas para browse_tabela(): produto_pesquisa(),
  relatorio_produtos_minimo() e relatorio_produtos_fora_validade()
  (cor vermelha/verde por linha preservada), relatorio_produtos_
  vendidos() e relatorio_entradas_produtos() (agrupamento visual por
  docnr/data/id/fornecedor preservado inserindo uma linha em branco
  no array entre grupos, no lugar do antigo salto de linha manual).
  relatorio_vendas_diarias() não foi alterada (tabela pequena, sem o
  problema de sobreposição, como já registrado antes).
- Corrigido de brinde um bug de formatação encontrado durante a
  conversão: preço/custo eram convertidos de ponto para vírgula
  direto (ex: "5" ficava "5" em vez de "5,00", "4.9" ficava "4,9" em
  vez de "4,90") - faltava garantir 2 casas decimais antes da troca,
  como o antigo "%10.2f" do printf já garantia. Corrigido com
  printf %.2f antes da substituição em todas as 3 telas afetadas
  (produto_pesquisa, relatorio_produtos_vendidos,
  relatorio_entradas_produtos).
- Todas as ~30 chamadas de imprimirCabecalho*()/dispbox() e a lógica
  manual de paginação "Página: N" foram removidas dessas 5 funções -
  ficaram significativamente mais curtas e simples.
- Validado com teste de integração cobrindo: formatação de preço em 3
  precisões diferentes, cor por linha vermelho/verde, agrupamento com
  linha separadora na posição correta, e navegação (seta+Enter)
  retornando o registro certo.

[qui 13 ago 2026 05:27] BROWSE_TABELA() - COR POR COLUNA
------------------------------------------------------------------------
- browse_tabela() estendida com um novo parâmetro opcional (cores das
  colunas, mesma sintaxe pipe-delimited das larguras): permite definir
  uma cor fixa para cada campo/coluna individualmente, caindo na cor
  padrão da caixa quando não especificada para aquela coluna. Restaura
  a possibilidade de destacar campos específicos (ex: preço em
  vermelho, quantidade em ciano) que existia no código antigo baseado
  em printf e havia se perdido na conversão para o novo widget.
- Prioridade quando cor de linha e cor de coluna coexistem: a cor de
  linha (ex: vermelho para estoque abaixo do mínimo) sempre vence,
  destacando a linha inteira sem exceção.
- Achado e corrigido durante o desenvolvimento: colorir campo por
  campo terminando cada um com reset de cor cancelava o vídeo reverso
  da linha selecionada no meio do caminho (o reset do ANSI limpa TODOS
  os atributos, não só a cor) - a linha ficava com metade destacada e
  metade normal. Corrigido fazendo a linha selecionada sempre renderizar
  de forma uniforme (reverso + cor de linha, sem cor por coluna); as
  cores por coluna só se aplicam às linhas que não estão em destaque.
- Aplicado em produto_pesquisa() como demonstração: QMIN e ESTOQUE em
  ciano, PREÇO em vermelho - restaurando exatamente as cores que a
  versão anterior (com printf manual) já usava.
- Validado com teste de integração usando dados reais de 2 produtos:
  confirmado que a cor cai exatamente nos campos certos (QMIN/ESTOQUE
  ciano, PREÇO vermelho, demais campos sem cor) tanto na linha
  selecionada (uniforme) quanto nas demais (por coluna), e que a
  navegação entre elas troca a formatação corretamente a cada tecla.

[qui 13 ago 2026 05:31] CORREÇÃO: ERRO DE LOCALE NO PRINTF (numero invalido)
------------------------------------------------------------------------
- Reportado erro em produção: "printf: 11.3: numero invalido" (e
  semelhantes) na tela de pesquisa de produtos. Causa: o bash força o
  printf a interpretar %f de acordo com LC_NUMERIC do sistema - em
  locale pt_BR (vírgula como separador decimal), um valor vindo do
  banco no formato ponto (ex: "11.3") é rejeitado como número
  inválido. O próprio código original já tinha essa lição aprendida
  em um lugar (troco em realizar_venda usa LC_ALL=C), mas os 3 printf
  %.2f novos adicionados na conversão para browse_tabela() (preço em
  produto_pesquisa/relatorio_produtos_vendidos, custo em
  relatorio_entradas_produtos) não tinham essa proteção. Corrigido
  prefixando os 3 com LC_NUMERIC=C, forçando a interpretação correta
  do valor bruto do banco independente do locale do sistema.
- Investigação revelou um problema relacionado, mais amplo e já
  pré-existente no código original (não introduzido nesta sessão): em
  vários lugares um valor JÁ formatado para exibição com vírgula (ex:
  "4,99") era passado para um formato %f do printf, que só aceita
  número de verdade - isso quebra mesmo sob locale C, independente do
  locale do sistema. Encontrado em relatorio_vendas_diarias() (soma
  mensal), realizar_venda() e produtos_entradas() (linha de item e
  linha de SUBTOTAL do carrinho). Corrigido trocando o formato de
  "%8.2f"/"%10.2f" para "%8s"/"%10s" nesses 5 pontos, já que o valor
  não precisa mais ser reformatado como número - só exibido como texto,
  mantendo o mesmo alinhamento visual (confirmado com teste direto).
- Validado: os 3 pontos com LC_NUMERIC=C testados com vários valores
  (inteiro, 1 e 2 casas decimais) sem regressão sob locale C; os 5
  pontos com troca de %f para %s testados com dados reais de carrinho,
  sem erro e com alinhamento idêntico ao formato %f original (quando
  este funcionava).

[qui 13 ago 2026 15:19] CORREÇÃO DEFINITIVA DO LOCALE + VENDAS DIÁRIAS
------------------------------------------------------------------------
- O erro "printf: X.Y: número inválido" persistiu mesmo com o prefixo
  LC_NUMERIC=C aplicado na correção anterior. Causa: prefixar uma
  variável de ambiente antes de um BUILTIN do bash (como printf) não
  funciona da mesma forma que antes de um comando externo - builtins
  rodam dentro do próprio processo do bash, que já carregou o estado
  de locale na inicialização; o prefixo temporário não força uma
  releitura confiável desse estado para aquela chamada específica.
- Corrigido de forma definitiva: criada formatar_2_casas(), que separa
  a parte inteira e decimal do valor manualmente (string) e usa só
  %d (inteiro) do printf para montar o resultado - nunca usa %f, que é
  a fonte do problema. %d nunca depende de locale. Substituídas as 3
  chamadas problemáticas (produto_pesquisa, relatorio_produtos_
  vendidos, relatorio_entradas_produtos) por essa função. Validado
  com os 7 valores exatos do erro reportado (32.4, 90.8, 44.5, 92.7,
  39.0, 17.1, 96.9) - todos corretos, sem erro.
- Nota: formatar_2_casas() trunca a casa decimal (não arredonda) -  
  correto para os 3 usos acima, pois lá o valor já vem com no máximo
  2 casas do banco (preço/custo validados na entrada). Para somas
  agregadas (SUM() do SQL, que podem ter cauda decimal por imprecisão
  de ponto flutuante), foi criada uma segunda função separada, veja
  abaixo.
- relatorio_vendas_diarias() convertida para browse_tabela(), como as
  outras 5 telas de relatório. A linha "SOMA" mensal foi preservada
  usando a cor de linha (destacada em azul). Aproveitando a conversão,
  corrigido também aqui o mesmo padrão de bug (valor já em vírgula
  sendo passado para %f) que afetava a linha de SOMA e o total diário.
- arredondar_moeda(): nova função para os casos de SUM() do SQL nesta
  tela especificamente - usa bc para arredondar corretamente (não só
  truncar) valores com cauda decimal por imprecisão de ponto
  flutuante, corrigindo também as inconsistências do próprio bc (saída
  "0" sem decimais, valores menores que 1 sem o zero à esquerda).
  Validado com o exemplo real de imprecisão "39.949999999999996" ->
  "39.95" (arredondado corretamente) e outros casos de borda.
- Simplificação aceita nesta conversão: o zebra-striping (linhas
  alternando ciano/preto) não foi preservado, já que browse_tabela()
  usa cor por LINHA de forma binária (linha tem cor especial ou usa a
  cor padrão) - manter tanto o destaque da linha SOMA quanto o
  zebra-striping ao mesmo tempo exigiria uma extensão adicional do
  widget, não implementada por ora.
- Validado com teste de integração simulando vendas cruzando 2 meses
  com valores de imprecisão real de ponto flutuante: agrupamento
  mensal, arredondamento e navegação todos corretos (somas mensais
  batendo com a soma manual esperada).

Todas as otimizações foram validadas comparando a saída antes/depois
(byte a byte quando aplicável) e testadas com casos de borda antes de
serem aplicadas, para garantir que o comportamento visível ao usuário
permanece o mesmo - só ficou mais rápido. Os dois bugs do TIni.Set()
foram reproduzidos primeiro (confirmando a falha), depois corrigidos e
revalidados com múltiplos cenários reais.

[qui 13 ago 2026 18:50] BROWSE_TABELA() - TÍTULO, UTF-8 E COR POR CÉLULA
------------------------------------------------------------------------
- browse_tabela() ganhou um 5º parâmetro opcional (título), passado
  direto pra box() no mesmo padrão já usado por show_menu() - antes a
  caixa sempre abria sem título na borda. Aplicado nas 7 chamadas
  existentes (produto_pesquisa, fornecedor_pesquisa e os 5 relatórios).
- Corrigido bug de alinhamento sob locale POSIX/C (este ambiente não
  tem pt_BR instalado): o bash conta bytes em vez de caracteres
  visuais em ${#string}/${string:0:N}/printf %-Ns, e um C/Ã acentuado
  ocupa 2 bytes mas 1 posição visual - isso desalinhava o cabeçalho
  (com acento) das linhas de dado (sem acento). Corrigido com
  utf8_campo(), que trunca/preenche por caractere visual e nunca corta
  um acento no meio. Validado com 8 casos de borda (acento no limite
  exato da largura, string só de acentos, string vazia, etc), todos
  passando.
- browse_tabela() estendida com um terceiro nível de cor, por CÉLULA
  individual: uma linha de dado pode ter o dobro de campos (N dados +
  N cores, uma cor por coluna daquela linha específica), permitindo
  por exemplo colorir só a célula do ESTOQUE sem afetar as demais.
  Prioridade mantida: cor de linha > cor de célula > cor de coluna
  (estática) > padrão.
- Encontrado um erro no teste manual (não no código): uma linha de
  teste com contagem de pipes errada (7 campos em vez dos 6 esperados
  para 3 colunas) caiu sem querer no branch de cor de LINHA em vez de
  cor por CÉLULA. Corrigido o teste e revalidado isoladamente: com a
  contagem certa (2xN campos), só a célula do ESTOQUE fica colorida,
  as outras duas (ID, DESCRIÇÃO) permanecem sem cor própria.
- Aplicada a cor dinâmica no campo ESTOQUE de produto_pesquisa():
  negativo em vermelho, positivo ou zero em ciano, calculado linha a
  linha ao montar linhas_produto, usando o novo formato de cor por
  célula (9 campos de dado + 9 de cor, cor preenchida só no índice do
  ESTOQUE). Substitui a cor estática ciano que essa coluna tinha antes.
- Validado com teste isolado da lógica de geração das cores (estoque
  negativo, zero e positivo) confirmando 9 campos de cor sempre
  gerados, com a cor certa (vermelho/ciano) sempre no índice do
  ESTOQUE e os demais 8 campos vazios.

[qui 13 ago 2026 18:56] RELATÓRIO DE VENDAS DIÁRIAS - NOVOS CAMPOS
------------------------------------------------------------------------
- relatorio_vendas_diarias() ganhou 3 colunas novas, calculadas a
  partir dos campos já existentes na tabela vendas (quantidade e
  docnr), sem alterar o schema: QTD ITENS (soma de quantidade no dia),
  Nº VENDAS (contagem de docnr distintos no dia - cada cupom/venda
  pode ter várias linhas de item, uma por produto) e TICKET MÉDIO
  (total do dia dividido pelo nº de vendas do dia).
- A query SQL foi ampliada de "SELECT date(data), SUM(total)" para
  incluir também "SUM(quantidade)" e "COUNT(DISTINCT docnr)" no mesmo
  GROUP BY date(data), sem custo adicional relevante.
- A linha SOMA mensal (destacada em azul) também ganhou os 3 novos
  valores agregados: soma de QTD ITENS e Nº VENDAS do mês, e o ticket
  médio recalculado sobre o total e o nº de vendas do mês inteiro (não
  é a média dos tickets médios diários).
- Ticket médio usa a mesma arredondar_moeda() já existente (via bc),
  então fica protegido do mesmo bug de locale documentado nas rodadas
  anteriores; divisão por zero evitada checando nº de vendas > 0 antes
  de dividir.
- Validado com teste isolado da lógica de agregação usando dados
  simulados (3 dias, 2 meses, múltiplas vendas no mesmo dia com docnr
  repetido) e depois um teste fim-a-fim rodando a consulta SQL real
  (via módulo sqlite3 do Python, já que o binário sqlite3 não está
  disponível neste ambiente de teste) contra um banco de teste com 5
  linhas de venda, conferindo cada valor manualmente: totais, soma de
  itens, contagem de vendas distintas por docnr e ticket médio diário
  e mensal, todos batendo com o esperado.

[qui 13 ago 2026 19:09] RELATÓRIO DE VENDAS DIÁRIAS - SOMA, PERÍODO E TOTAL GERAL
------------------------------------------------------------------------
- A cor da linha SOMA (subtotal mensal) trocada de azul para vermelho,
  e uma linha em branco separadora passou a ser inserida antes de cada
  SOMA, destacando visualmente o subtotal das linhas de dados do mês.
- O título da caixa do relatório (browse_tabela) passou a incluir o
  período consultado, no formato "TÍTULO - PERÍODO dd-mm-aaaa/dd-mm-
  aaaa", usando as datas exatamente como digitadas pelo usuário (antes
  da conversão pro formato US usado na query SQL).
- Adicionada uma linha TOTAL GERAL ao final do relatório (também em
  vermelho, com separadora antes): soma do total, quantidade de itens
  e nº de vendas de TODO o período consultado (todos os meses juntos),
  não só do último mês - diferente da SOMA mensal, que continua sendo
  por mês. Ticket médio geral recalculado sobre esses totais do
  período inteiro.
- Validado com teste isolado da lógica de acumulação (2 meses, 3 dias)
  conferindo manualmente que TOTAL GERAL bate com a soma de todos os
  dias (total, quantidade e nº de vendas), independente de quantos
  meses o período abranja.

[qui 13 ago 2026 22:08] RELATÓRIO DE VENDAS DIÁRIAS - ROTULOS, SEPARADOR E MENSAGEM DE PROCESSAMENTO
------------------------------------------------------------------------
- Rótulos renomeados para deixar claro o escopo de cada total: a
  antiga "SOMA" (subtotal por mês) virou "SOMA MENSAL", e a antiga
  "TOTAL GERAL" (soma de todo o período) virou "SOMA GERAL".
- Reposicionada a linha em branco separadora: antes vinha ANTES da
  SOMA MENSAL (separando os dias da soma do próprio mês); agora vem
  DEPOIS, separando a SOMA MENSAL de um mês das linhas de dados do
  próximo mês. Sequência final: dias do mês 1, SOMA MENSAL, linha em
  branco, dias do mês 2, SOMA MENSAL, linha em branco, SOMA GERAL.
- Adicionada mensagem "Processando..." (em amarelo) exibida na tela
  logo antes da consulta SQL e do loop de agregação rodarem, dando
  feedback visual em relatórios com muitos dias/meses.
- Validado com teste isolado da nova ordem das linhas (2 meses, 3
  dias), conferindo que a sequência bate exatamente com o padrão
  esperado: item, item, SOMA MENSAL, branco, item, SOMA MENSAL,
  branco, SOMA GERAL.

[qui 13 ago 2026 22:28] MENSAGEM DE PROCESSAMENTO E CORREÇÃO DA GET() - SETAS/HOME/END/DELETE
------------------------------------------------------------------------
- relatorio_vendas_diarias(): a mensagem "Processando..." passou a usar
  a função mensagem() já existente (a mesma usada em outras telas para
  avisos rápidos), em vez de um print() avulso numa linha fixa. Chamada
  com timeout 0 (mesmo padrão do exemplo já comentado no arquivo em
  registrar_venda), que não bloqueia: o inkey() interno usa read -t 0,
  que só verifica se tem tecla no buffer e retorna na hora, sem
  esperar. A caixa aparece e some sozinha assim que o browse_tabela
  desenha a tabela final.
- Corrigido bug antigo na get() (usada em TODOS os campos de entrada
  do sistema, inclusive as datas dos relatórios): qualquer sequência
  iniciada por ESC - inclusive as setas do teclado, que no terminal
  chegam como ESC seguido de mais bytes (ex: seta esquerda = ESC [ D)
  - caía no mesmo case do ESC puro e abortava o campo inteiro. Só o
  backspace funcionava pra editar.
- Reescrita a get() com navegação de cursor de verdade, não só
  ignorando as teclas: distingue ESC puro (sem mais bytes dentro de
  0.05s - cancela o campo, como antes) de sequência CSI/SS3 (ESC [ ou
  ESC O seguido de bytes de parâmetro e um byte final - consome só os
  bytes da própria sequência, sem tocar no que for digitado depois).
  Setas esquerda/direita movem o cursor dentro do texto (travando nos
  limites 0 e fim da string), Home/End pulam pro início/fim, Delete
  apaga o caractere sob o cursor, backspace continua apagando o de
  trás, e digitar em qualquer posição insere ali (não só no final).
  Setas cima/baixo e PgUp/PgDn são ignoradas (não fazem sentido num
  campo de linha única), mas não abortam mais. O campo inteiro é
  redesenhado a cada tecla (setpos + reimpressão), já que os campos do
  sistema são curtos (datas, ids etc.), com um contador de tamanho
  anterior (prev_len) pra apagar sobra de caracteres quando o texto
  encolhe (backspace/delete no meio).
- Validado com dois conjuntos de testes isolados simulando a leitura
  de teclado via pipe (sem depender de terminal real): 1) que setas
  não abortam mais e não "engolem" o próximo caractere digitado logo
  em seguida (risco de timing, já que num pipe todos os bytes ficam
  disponíveis de uma vez); 2) navegação completa - Home, End, seta
  esquerda/direita travando nos limites, Delete no meio da string,
  inserção no meio respeitando maxlen, e ESC puro ainda cancelando
  normalmente. Todos os casos bateram com o esperado.

[qui 13 ago 2026 23:49] MENSAGEM DE PROCESSAMENTO NAS DEMAIS TELAS COM BROWSE_TABELA
------------------------------------------------------------------------
- Estendida a mensagem "Processando..." (via mensagem(), timeout 0, sem
  bloquear) da relatorio_vendas_diarias() pras outras 6 telas que usam
  browse_tabela: produto_pesquisa(), relatorio_produtos_minimo(),
  relatorio_produtos_fora_validade(), fornecedor_pesquisa(),
  relatorio_produtos_vendidos() e relatorio_entradas_produtos().
- Inserida sempre no mesmo ponto em cada função: logo depois da
  validação do campo de busca (identificador == "*" vira busca-tudo) e
  antes do bloco de queries/loop que monta as linhas da tabela - ou
  seja, antes de qualquer processamento que antecede o browse_tabela,
  igual já era feito no relatório de vendas diárias.
- produto_pesquisa() não tem variável $xtitle local (usa o gettext
  "PESQUISAR PRODUTOS" direto em cada chamada), então a mensagem
  reaproveita a mesma string ali também, em vez de introduzir uma
  variável nova só pra isso.

[sex 14 ago 2026 00:01] CALCULAR_LARGURAS() - CRESCIMENTO PROPORCIONAL PRA PREENCHER O ESPAÇO
------------------------------------------------------------------------
- Encontrada a causa raiz de tabelas com espaço vazio sobrando à
  direita da caixa (ex: relatório de vendas diárias): calcular_
  larguras() só sabia ENCOLHER colunas quando a soma ideal não cabia
  no espaço disponível - se sobrava espaço, ela simplesmente devolvia
  as larguras ideais sem tocar, mesmo em colunas já marcadas como
  flexíveis (flag "1"). Por isso mesmo relatórios que já usavam a
  flag flexível numa coluna (ex: DESCRIÇÃO em produto_pesquisa) não
  se esticavam quando o terminal era mais largo que o necessário.
- Adicionado um novo ramo simétrico ao de encolher: quando sobra
  espaço, distribui a sobra proporcionalmente entre as colunas
  marcadas como flexíveis (peso = largura ideal de cada uma), com
  ajuste fino jogando o resto do arredondamento pra primeira coluna
  flexível - mesmo padrão de ajuste fino que o ramo de encolher já
  usava. Sem nenhuma coluna flexível, comportamento idêntico ao
  anterior (preserva compatibilidade com quem já usa flags "0|0|...").
- relatorio_vendas_diarias(): as 5 colunas (DATA, TOTAL DIA, QTD
  ITENS, Nº VENDAS, TICKET MÉDIO) marcadas como flexíveis (antes
  todas "0"), já que não tem uma coluna de texto longo tipo descrição
  pra absorver sozinha o espaço extra - faz mais sentido crescer
  todas proporcionalmente.
- Validado com teste isolado da função (5 cenários: sobra espaço com
  todas as colunas flexíveis, sobra espaço com só uma coluna flexível,
  espaço insuficiente/encolhendo, espaço exatamente igual ao ideal, e
  sobra espaço sem nenhuma coluna flexível) e depois um teste de
  integração extraindo a função exatamente como ficou no arquivo real
  e rodando com valores de lastcol representativos (terminal de 80 e
  120 colunas), conferindo que a soma final das larguras + separadores
  + bordas bate exatamente com o espaço disponível em cada caso.

[sex 14 ago 2026 00:21] PESQUISAR PRODUTOS - CORES DO ESTOQUE E PREÇO
------------------------------------------------------------------------
- Corrigido produto_pesquisa(): o pedido de colorir o ESTOQUE conforme
  o QMIN tinha ficado só na prévia de uma rodada anterior, sem nunca
  ter sido efetivamente aplicado no arquivo real - a cor ainda estava
  baseada no sinal (negativo/positivo), não no QMIN.
- ESTOQUE agora usa 3 faixas de cor: vermelho se menor que o QMIN,
  amarelo se igual ao QMIN, ciano se maior que o QMIN.
- PREÇO passou a ser sempre amarelo (cor estática de coluna; antes
  era vermelho).
- Validado com teste isolado das 3 faixas (menor, igual, maior que o
  QMIN, incluindo casos com valores negativos), todos batendo com o
  esperado.

[sex 14 ago 2026 00:31] BUG CRÍTICO NO BROWSE_TABELA() - CAMPO DE COR VAZIO NO FINAL SUMIA
------------------------------------------------------------------------
- Encontrado por que o ESTOQUE de produto_pesquisa() não estava sendo
  colorido mesmo depois da correção anterior: bug no PRÓPRIO
  browse_tabela(), não no produto_pesquisa(). O parsing de cada linha
  usava um read -a com o separador pipe, terminando o here-string sem
  nenhum caractere extra no final -
  e o bash tem um comportamento pouco conhecido: read -a descarta
  SEMPRE UM campo vazio no final quando a string termina em "|" (ex:
  "a|b|" lê só 2 campos em vez dos 3 esperados). Como CODEBAR (última
  coluna) nunca recebe cor própria, o campo de cor dele fica vazio e
  no final da string - o read descartava esse campo, fazendo a linha
  ter 17 campos em vez dos 18 esperados (9 dados + 9 cores), quebrando
  a checagem "N×2 = cor por célula" e fazendo o ESTOQUE (que não é a
  última coluna) nunca ser reconhecido como colorido.
- Corrigido acrescentando um "|" extra no final da string antes do
  read ("...<<<"${browse_dados[idx]}|""), que absorve esse descarte:
  não importa quantos campos vazios existam no final da linha
  original, a contagem final bate exatamente com o número real de
  campos. Correção feita direto no browse_tabela(), então vale pra
  qualquer relatório que use cor por célula ou cor de linha, não só
  produto_pesquisa.
- Validado com 3 rodadas de teste isolado: 1) o comportamento do bug
  em vários cenários (string terminando com 1, 2 ou mais campos
  vazios); 2) que acrescentar o "|" extra sempre resulta na contagem
  matematicamente correta (nº de pipes + 1), em qualquer cenário,
  inclusive sem trailing vazio (sem regressão); 3) teste de ponta a
  ponta reproduzindo a linha exata do produto 27 do print enviado
  (estoque -3, qmin 18), confirmando que agora é detectado como cor
  por célula e o ESTOQUE recebe vermelho corretamente. Também
  confirmado que uma linha vazia (separador usado no relatório de
  vendas diárias) continua se comportando igual, sem regressão.

[sex 14 ago 2026 00:31] AJUSTE NO CABEÇALHO DE LICENÇA
------------------------------------------------------------------------
- Acrescentado um espaço extra entre "#" e o texto nas 3 linhas de
  copyright/direitos reservados no topo do arquivo (antes "# Copyright
  ...", agora "#  Copyright ..."). Nada mais no cabeçalho foi alterado
  - o texto completo da licença (redistribuição, garantias) permanece
  intacto.

[sex 14 ago 2026 00:48] READ_KEY(), FORA_VALIDADE, COPYRIGHT E CAMPOS SOBREPOSTOS
------------------------------------------------------------------------
- read_key() (navegação do browse_tabela: setas, PgUp/PgDn, Home/End)
  tinha o mesmo problema de timing já corrigido hoje no get(): só
  esperava 0.01s (10ms) pelo resto da sequência ANSI depois do ESC.
  Curto demais - em terminais com latência (SSH, tmux, sistema
  ocupado), a seta era interpretada como ESC solto, fazendo a tabela
  fechar sozinha (return 1) ao navegar, e sobrando os bytes "[A"/"[B"
  no buffer pra aparecerem como lixo na tela seguinte. Timeout
  aumentado pra 0.05s, mesmo valor já validado no get().
- relatorio_produtos_fora_validade(): trocada a cor de LINHA INTEIRA
  (vermelho se validade vencida, verde se não) pela cor só no campo
  ESTOQUE, no mesmo esquema de 3 faixas do PESQUISAR PRODUTOS
  (vermelho < QMIN, amarelo == QMIN, ciano > QMIN) - já que a consulta
  já filtra só produtos vencidos, não fazia sentido colorir a linha
  toda por um critério (validade) que já é garantido pelo próprio
  filtro da tela.
- Cabeçalho: acrescentado mais 1 espaço nas 3 linhas de copyright
  (agora "#   Copyright...", 3 espaços) pra alinhar com as linhas
  vizinhas que usam tab (equivalente a um tab-stop de 4).
- relatorio_produtos_vendidos() e relatorio_entradas_produtos(): os
  dois campos de busca ("Pesquisar por:" e "Agrupar:") ficavam lado a
  lado na mesma linha, o segundo começando em lastcol/2. Só que o
  primeiro prompt sozinho já tem 74 caracteres - maior que lastcol/2
  em qualquer terminal até 148 colunas, ou seja, sobrepunha o segundo
  campo em praticamente qualquer tela real. Corrigido colocando cada
  campo em sua própria linha (caixa de busca cresceu de 3 pra 4
  linhas), e os browse_tabela() correspondentes desceram 1 linha pra
  não colidir com a caixa maior.
- Validado cada mudança isoladamente: cor por célula do fora_validade
  testada com o mesmo padrão N×2 já usado no PESQUISAR PRODUTOS;
  comprimento dos dois prompts comparado contra larguras de terminal
  de 80 a 132 colunas, confirmando que agora cabem cada um sozinho na
  própria linha sem sobrepor nada.
################################################################################
'