package controller;

import [Link];
import [Link];
import [Link];

public class ControladorAcesso {

// 1. Parte do Singleton - a gente guarda a única instância aqui

private static ControladorAcesso instanciaUnica;

// 2. O repositório que vamos usar (pela interface)

private IRepFuncionario repositorioFuncionario;

// 3. Construtor privado - só a própria classe pode criar uma instância

private ControladorAcesso() {
// Aqui a gente pega a instância do repositório de funcionários
[Link] = [Link]();
}

// 4. Método para pegar a instância (Singleton)

public static ControladorAcesso getInstancia() {
// Se não existir ainda, cria uma nova
if (instanciaUnica == null) {
instanciaUnica = new ControladorAcesso();
}
return instanciaUnica;
}

// Método para verificar login e senha

public boolean autenticar(String login, String senha) {
// Primeiro verifica se não são nulos
if (login == null || senha == null) {
return false;
}

// Pega todos os funcionários do repositório

Funcionario[] todosFuncionarios = [Link]();

// Vai um por um pra ver se acha o login e senha

for (int i = 0; i < [Link]; i++) {
Funcionario func = todosFuncionarios[i];

// Verifica se o login e senha batem

if ([Link]() != null && [Link]().equals(login) &&
[Link]() != null && [Link]().equals(senha)) {
return true; // Achou!
}
}

// Se chegou aqui, não encontrou

return false;
}

// Método para verificar permissão

public boolean temPermissao(int idFuncionario, String permissao) {
// Primeiro busca o funcionário pelo ID
Funcionario funcionario = [Link](idFuncionario);
 // Se não encontrou o funcionário, retorna false
if (funcionario == null) {
return false;
}

// Pega todas as permissões do funcionário

String[] permissoes = [Link]();

// Verifica se a permissão está na lista

for (int i = 0; i < [Link]; i++) {
if (permissoes[i].equals(permissao)) {
return true; // Tem a permissão!
}
}

// Se chegou aqui, não tem a permissão

return false;
}
}package controller;

import [Link];
import [Link];
import [Link];

public class ControladorCarrinho {

private static ControladorCarrinho instancia;
private IRepProduto repProduto;
private Produto[] itens;
private int quantidadeItens;

private ControladorCarrinho() {
[Link] = [Link]();
[Link] = new Produto[100];
[Link] = 0;
}

public static synchronized ControladorCarrinho getInstancia() {

if (instancia == null) {
instancia = new ControladorCarrinho();
}
return instancia;
}

public void adicionarItem(int idProduto) {

Produto produto = [Link](idProduto);
if (produto == null) {
throw new RuntimeException("Produto não encontrado");
}
itens[quantidadeItens++] = produto;
}

public double calcularTotal() {

double total = 0;
for (int i = 0; i < quantidadeItens; i++) {
total += itens[i].getPreco();
}
return total;
}
}package controller;
import [Link];
import [Link];
import [Link];

public class ControladorCliente {

private static ControladorCliente instancia;
private IRepCliente repCliente;

private ControladorCliente() {
[Link] = [Link]();
}

public static synchronized ControladorCliente getInstancia() {

if (instancia == null) {
instancia = new ControladorCliente();
}
return instancia;
}

// Cadastra um novo cliente

public void cadastrarCliente(Cliente cliente) {
if (cliente == null) {
throw new IllegalArgumentException("Cliente não pode ser nulo");
}
[Link](cliente);
}

// Autentica cliente por ID e senha

public boolean autenticarCliente(int id, String senha) {
if (senha == null || [Link]()) {
return false;
}

Cliente cliente = [Link](id);

return cliente != null && [Link]().equals(senha);
}

// Busca cliente por ID e retorna como String

public String buscarCliente(int id) {
Cliente cliente = [Link](id);
if (cliente == null) {
return "Cliente não encontrado";
}
return [Link](); // Usa o toString() da classe Cliente
}

// Método adicional útil

public Cliente obterCliente(int id) {
return [Link](id);
}
}package controller;

import [Link];
import [Link];
import [Link];

public class ControladorFatura {

private static ControladorFatura instancia;
private IRepFatura repFatura;

private ControladorFatura() {
[Link] = [Link]();
}

public static synchronized ControladorFatura getInstancia() {

if (instancia == null) {
instancia = new ControladorFatura();
}
return instancia;
}

public void emitirFatura(Fatura fatura) {

if ([Link]() > 0) {
[Link](fatura);
}
}
}package controller;

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class ControladorFuncionario {

private static ControladorFuncionario instancia;
private IRepFuncionario repFuncionario;

// Construtor privado para Singleton

private ControladorFuncionario() {
[Link] = [Link]();
}

// Método Singleton para obter a instância

public static synchronized ControladorFuncionario getInstancia() {
if (instancia == null) {
instancia = new ControladorFuncionario();
}
return instancia;
}

// Método para contratar funcionário

public boolean contratarFuncionario(Funcionario funcionario) {
if (funcionario == null) {
[Link]("Erro: Funcionário não pode ser nulo");
return false;
}

boolean resultado = [Link](funcionario);

if (resultado) {
[Link]("Funcionário " + [Link]() + " contratado
com sucesso!");
} else {
[Link]("Erro ao contratar funcionário! Limite máximo
atingido.");
}
 return resultado;
}

// Método para buscar funcionário por ID

public Funcionario buscarFuncionario(int id) {
Funcionario funcionario = [Link](id);
if (funcionario == null) {
[Link]("Funcionário com ID " + id + " não encontrado!");
}
return funcionario;
}

// Método para listar todos os funcionários

public void listarTodosFuncionarios() {
Funcionario[] funcionarios = [Link]();
if ([Link] == 0) {
[Link]("Nenhum funcionário cadastrado!");
return;
}

[Link]("\n=== LISTA DE FUNCIONÁRIOS ===");

for (int i = 0; i < [Link]; i++) {
Funcionario func = funcionarios[i];
[Link]("ID: " + [Link]() +
" | Nome: " + [Link]() +
" | Departamento: " + [Link]() +
" | Tipo: " + [Link]().getSimpleName());
}
}

// Método para atualizar dados do funcionário

public boolean atualizarFuncionario(Funcionario funcionario) {
boolean resultado = [Link](funcionario);
if (resultado) {
[Link]("Dados do funcionário atualizados com sucesso!");
} else {
[Link]("Erro ao atualizar funcionário!");
}
return resultado;
}

// Método para demitir funcionário

public boolean demitirFuncionario(int id) {
boolean resultado = [Link](id);
if (resultado) {
[Link]("Funcionário demitido com sucesso!");
} else {
[Link]("Erro ao demitir funcionário!");
}
return resultado;
}

// Método para listar funcionários por departamento

public void listarPorDepartamento(String departamento) {
Funcionario[] funcionarios =
[Link](departamento);
if ([Link] == 0) {
[Link]("Nenhum funcionário no departamento " + departamento);
return;
 }

[Link]("\n=== FUNCIONÁRIOS DO DEPARTAMENTO " +

[Link]() + " ===");
for (int i = 0; i < [Link]; i++) {
Funcionario func = funcionarios[i];
[Link]("ID: " + [Link]() +
" | Nome: " + [Link]() +
" | Tipo: " + [Link]().getSimpleName());
}
}

// Método para calcular salário de um funcionário

public double calcularSalarioFuncionario(int idFuncionario) {
Funcionario funcionario = [Link](idFuncionario);
if (funcionario == null) {
[Link]("Funcionário não encontrado!");
return 0.0;
}

if (funcionario instanceof FuncionarioAssalariado) {

FuncionarioAssalariado assalariado = (FuncionarioAssalariado) funcionario;
return [Link]() + [Link]();
}
else if (funcionario instanceof FuncionarioHorista) {
FuncionarioHorista horista = (FuncionarioHorista) funcionario;
double salario = [Link]() * [Link]();
if ([Link]()) {
salario *= 1.2; // Adicional de 20% para noturno
}
return salario;
}
else if (funcionario instanceof FuncionarioComissionado) {
FuncionarioComissionado comissionado = (FuncionarioComissionado)
funcionario;
return [Link]() * [Link]();
}

[Link]("Tipo de funcionário não reconhecido");

return 0.0;
}
}package controller;

import [Link];
import [Link];
import [Link];

public class ControladorPagamento {

private static ControladorPagamento instancia;
private RepFatura repFatura;

private ControladorPagamento() {
[Link] = [Link]();
}

public static synchronized ControladorPagamento getInstancia() {

if (instancia == null) {
instancia = new ControladorPagamento();
}
 return instancia;
}

public boolean processarPagamento(IPagamento pagavel, Fatura fatura, String metodo)

{
boolean sucesso = [Link]([Link]());
if (sucesso) {
[Link]([Link](), metodo);
[Link](fatura);
}
return sucesso;
}
}package controller;

import [Link];
import [Link];
import [Link];

public class ControladorProduto {

private static ControladorProduto instancia;
private IRepProduto repProduto;

private ControladorProduto() {
[Link] = [Link]();
}

public static synchronized ControladorProduto getInstancia() {

if (instancia == null) {
instancia = new ControladorProduto();
}
return instancia;
}

// ---- MÉTODOS BÁSICOS (CRUD) ---- //

public boolean cadastrarProduto(Produto produto) {
if (produto != null && [Link]() > 0) {
[Link](produto);
return true;
}
return false;
}

public Produto buscarProduto(int id) {

return [Link](id);
}

public Produto[] listarTodosProdutos() {

return [Link]();
}

public boolean atualizarProduto(Produto produto) {

return produto != null && [Link](produto);
}

public boolean removerProduto(int id) {

return [Link](id);
}

// ---- MÉTODOS DE BUSCA ---- //

public Produto[] buscarProdutosPorNome(String nome) {
if (nome == null || [Link]().isEmpty()) {
return new Produto[0];
}
return [Link](nome);
}

public Produto[] buscarProdutosPorCategoria(String categoria) {

if (categoria == null || [Link]().isEmpty()) {
return new Produto[0];
}
return [Link](categoria);
}

public int getQuantidadeProdutos() {

return [Link]();
}

// ---- MÉTODOS DE CATEGORIA ---- //

public boolean editarNomeCategoria(String nomeAntigo, String nomeNovo) {
if (nomeAntigo == null || nomeNovo == null || [Link]().isEmpty()) {
return false;
}

Produto[] produtos = [Link](nomeAntigo);

if ([Link] == 0) {
return false;
}

for (Produto p : produtos) {

[Link](nomeNovo);
[Link](p);
}
return true;
}

public boolean podeRemoverCategoria(String nomeCategoria) {

if (nomeCategoria == null || [Link]().isEmpty()) {
return false;
}
return [Link](nomeCategoria).length == 0;
}

public String[] listarTodasCategorias() {

Produto[] todosProdutos = [Link]();
String[] categorias = new String[[Link]];
int count = 0;

for (Produto p : todosProdutos) {

boolean categoriaJaExiste = false;
for (int i = 0; i < count; i++) {
if (categorias[i].equalsIgnoreCase([Link]())) {
categoriaJaExiste = true;
break;
}
}
if (!categoriaJaExiste) {
categorias[count++] = [Link]();
}
 }

String[] resultado = new String[count];

[Link](categorias, 0, resultado, 0, count);
return resultado;
}

// ---- MÉTODOS DE IMAGENS ---- //

public boolean adicionarImagem(int idProduto, String caminhoImagem) {
if (caminhoImagem == null || [Link]().isEmpty()) {
return false;
}
return [Link](idProduto, caminhoImagem);
}

public boolean removerImagem(int idProduto, String caminhoImagem) {

if (caminhoImagem == null || [Link]().isEmpty()) {
return false;
}
return [Link](idProduto, caminhoImagem);
}

public boolean definirImagemPrincipal(int idProduto, String caminhoImagem) {

if (caminhoImagem == null || [Link]().isEmpty()) {
return false;
}
return [Link](idProduto, caminhoImagem);
}

public String[] listarImagens(int idProduto) {

return [Link](idProduto);
}

public String getImagemPrincipal(int idProduto) {

return [Link](idProduto);
}

// ---- MÉTODOS DE ESTOQUE ---- //

public boolean registrarVenda(int idProduto, int quantidade) {
if (quantidade <= 0) return false;
return [Link](idProduto, -quantidade);
}

public boolean reporEstoque(int idProduto, int quantidade) {

if (quantidade <= 0) return false;
return [Link](idProduto, quantidade);
}

public String verificarEstoque(int idProduto) {

Produto p = [Link](idProduto);
if (p == null) return "Produto não encontrado";

return "Estoque: " + [Link]() +

" | Mínimo: " + [Link]() +
([Link]() ? " (ESTOQUE BAIXO!)" : "");
}

public void emitirAlertasEstoque() {

Produto[] produtos = [Link]();
 if ([Link] == 0) {
[Link]("Nenhum produto com estoque baixo");
return;
}

[Link]("==== ALERTAS DE ESTOQUE ====");

for (Produto p : produtos) {
[Link](
[Link]() + " - Estoque: " + [Link]() +
" (Mínimo: " + [Link]() + ")"
);
}
}
}package controller;

import [Link];
import [Link];
import [Link];
import [Link];

public class ControladorPromocoes {

private static ControladorPromocoes instancia;
private IRepPromocao repPromocao;

private ControladorPromocoes() {
[Link] = [Link]();
}

public static synchronized ControladorPromocoes getInstancia() {

if (instancia == null) {
instancia = new ControladorPromocoes();
}
return instancia;
}

// Cria uma promoção para um produto específico

public boolean criarPromocaoProduto(int idProduto, double valorDesconto, boolean
isPercentual,
Date dataInicio, Date dataFim, String
descricao) {
Promocao promocao = new Promocao(
[Link]() + 1,
idProduto,
valorDesconto,
isPercentual,
dataInicio,
dataFim,
descricao
);
return [Link](promocao);
}

// Cria um cupom de desconto geral

public boolean criarCupom(String codigo, double valorDesconto, boolean
isPercentual,
Date dataInicio, Date dataFim, String descricao, int
usosMaximos) {
Promocao cupom = new Promocao(
[Link]() + 1,
 codigo,
valorDesconto,
isPercentual,
dataInicio,
dataFim,
descricao,
usosMaximos
);
return [Link](cupom);
}

// Aplica um cupom de desconto

public double aplicarCupom(double valorOriginal, String codigoCupom) {
Promocao cupom = [Link](codigoCupom);
if (cupom != null && [Link]()) {
return [Link](valorOriginal);
}
return valorOriginal;
}

// Busca promoções ativas para um produto

public Promocao[] buscarPromocoesPorProduto(int idProduto) {
return [Link](idProduto);
}

// Busca cupons ativos

public Promocao[] listarCuponsAtivos() {
return [Link]();
}

// Desativa uma promoção/cupom

public boolean desativarPromocao(int idPromocao) {
Promocao promocao = [Link](idPromocao);
if (promocao != null) {
[Link](false);
return [Link](promocao);
}
return false;
}

// Verifica se um cupom é válido

public boolean validarCupom(String codigoCupom) {
Promocao cupom = [Link](codigoCupom);
return cupom != null && [Link]() && [Link]();
}

// Obtém todas as promoções (para relatórios)

public Promocao[] listarTodasPromocoes() {
return [Link]();
}
}package controller;

import [Link];
import [Link];
import [Link];

public class ControladorRelatorio {

private static ControladorRelatorio instancia;
private IRepVenda repVenda;
private ControladorRelatorio() {
[Link] = [Link]();
}

public static synchronized ControladorRelatorio getInstancia() {

if (instancia == null) {
instancia = new ControladorRelatorio();
}
return instancia;
}

public void gerarRelatorioVendas(Date inicio, Date fim) {

[Link]("Relatório de vendas gerado para o período: "
+ inicio + " até " + fim);
}
}package controller;

import [Link];
import [Link];
import [Link];
import [Link];

public class ControladorVenda {

private static ControladorVenda instancia;
private IRepVenda repVenda;

private ControladorVenda() {
[Link] = [Link]();
}

public static synchronized ControladorVenda getInstancia() {

if (instancia == null) {
instancia = new ControladorVenda();
}
return instancia;
}

public void registrarVenda(Venda venda) {

// Validações complexas
if ([Link]() <= 0) {
throw new IllegalArgumentException("Valor inválido");
}
[Link](venda);
}

public double gerarRelatorioVendas(Date inicio, Date fim) {

Venda[] vendas = [Link](inicio, fim);
double total = 0;
for (Venda v : vendas) {
total += [Link]();
}
return total;
}
}package model;

public class CarrinhoCompra {

private int id;
private int idCliente;
private double valorTotal;

// Construtor
public CarrinhoCompra(int id, int idCliente, double valorTotal) {
[Link] = id;
[Link] = idCliente;
[Link] = valorTotal;
}

// Getters e Setters
public int getId() {
return id;
}

public void setId(int id) {

[Link] = id;
}

public int getIdCliente() {

return idCliente;
}

public void setIdCliente(int idCliente) {

[Link] = idCliente;
}

public double getValorTotal() {

return valorTotal;
}

public void setValorTotal(double valorTotal) {

[Link] = valorTotal;
}
}package model;

public class Cliente {

private int id;
private String nome;
private String email;
private String senha;
private String endereco;
private String telefone;

// Construtor
public Cliente(int id, String nome, String email, String senha, String endereco,
String telefone) {
[Link] = id;
[Link] = nome;
[Link] = email;
[Link] = senha;
[Link] = endereco;
[Link] = telefone;
}

// Getters e Setters
public int getId() {
return id;
}
public void setId(int id) {
[Link] = id;
}

public String getNome() {

return nome;
}

public void setNome(String nome) {

[Link] = nome;
}

public String getEmail() {

return email;
}

public void setEmail(String email) {

[Link] = email;
}

public String getSenha() {

return senha;
}

public void setSenha(String senha) {

[Link] = senha;
}

public String getEndereco() {

return endereco;
}

public void setEndereco(String endereco) {

[Link] = endereco;
}

public String getTelefone() {

return telefone;
}

public void setTelefone(String telefone) {

[Link] = telefone;
}
}package model;

import [Link];

public class Fatura {

// Atributos
private int id;
private int idPedido;
private int idCliente;
private double valorTotal;
private Date dataEmissao;
private Date dataVencimento;
private String status;
private String metodoPagamento;
private double valorPago;
private Date dataPagamento;
private String descricao;
private boolean possuiDesconto;
private double valorDesconto;

// Construtor completo
public Fatura(int id, int idPedido, int idCliente, double valorTotal,
Date dataEmissao, Date dataVencimento, String descricao) {
[Link] = id;
[Link] = idPedido;
[Link] = idCliente;
[Link] = valorTotal;
[Link] = dataEmissao;
[Link] = dataVencimento;
[Link] = descricao;
[Link] = "pendente";
[Link] = null;
[Link] = 0.0;
[Link] = null;
[Link] = false;
[Link] = 0.0;
}

// Construtor simplificado
public Fatura(int id, int idPedido, int idCliente, double valorTotal) {
[Link] = id;
[Link] = idPedido;
[Link] = idCliente;
[Link] = valorTotal;
[Link] = new Date();
[Link] = new Date([Link]() + 86400000 * 7);
[Link] = "Fatura do pedido " + idPedido;
[Link] = "pendente";
[Link] = null;
[Link] = 0.0;
[Link] = null;
[Link] = false;
[Link] = 0.0;
}

// Método para aplicar desconto

public void aplicarDesconto(double percentual) {
if (percentual > 0 && percentual <= 100) {
if ([Link]("pendente")) {
[Link] = [Link] * (percentual / 100);
[Link] = [Link] - [Link];
[Link] = true;
}
}
}

// Método para registrar pagamento

public void registrarPagamento(double valor, String metodo) {
if (valor > 0 && metodo != null) {
if ([Link]() == false) {
[Link] = valor;
[Link] = metodo;
[Link] = new Date();

if (valor >= ([Link] - [Link])) {

 [Link] = "pago";
} else {
[Link] = "parcial";
}
}
}
}

// Método para verificar se está vencida

public boolean estaVencida() {
Date hoje = new Date();
if ([Link]([Link])) {
if ([Link]("pago") == false) {
return true;
}
}
return false;
}

// Getters e Setters COMPLETOS (sem atalhos)

public int getId() {
return [Link];
}

public void setId(int id) {

[Link] = id;
}

public int getIdPedido() {

return [Link];
}

public void setIdPedido(int idPedido) {

[Link] = idPedido;
}

public int getIdCliente() {

return [Link];
}

public void setIdCliente(int idCliente) {

[Link] = idCliente;
}

public double getValorTotal() {

return [Link];
}

public void setValorTotal(double valorTotal) {

[Link] = valorTotal;
}

public Date getDataEmissao() {

return [Link];
}

public void setDataEmissao(Date dataEmissao) {

[Link] = dataEmissao;
}
public Date getDataVencimento() {
return [Link];
}

public void setDataVencimento(Date dataVencimento) {

[Link] = dataVencimento;
}

public String getStatus() {

if ([Link]()) {
return "atrasado";
} else {
return [Link];
}
}

public void setStatus(String status) {

[Link] = status;
}

public String getMetodoPagamento() {

return [Link];
}

public void setMetodoPagamento(String metodoPagamento) {

[Link] = metodoPagamento;
}

public double getValorPago() {

return [Link];
}

public void setValorPago(double valorPago) {

[Link] = valorPago;
}

public Date getDataPagamento() {

return [Link];
}

public void setDataPagamento(Date dataPagamento) {

[Link] = dataPagamento;
}

public String getDescricao() {

return [Link];
}

public void setDescricao(String descricao) {

[Link] = descricao;
}

public boolean isPossuiDesconto() {

return [Link];
}

public void setPossuiDesconto(boolean possuiDesconto) {

[Link] = possuiDesconto;
}

public double getValorDesconto() {

return [Link];
}

public void setValorDesconto(double valorDesconto) {

[Link] = valorDesconto;
}

// Método toString completo

@Override
public String toString() {
String metodo = [Link];
if (metodo == null) {
metodo = "Nenhum";
}

return "Fatura #" + [Link] +

" - Cliente #" + [Link] +
" | Pedido #" + [Link] + "\n" +
"Valor: R$" + [Link]("%.2f", [Link]) +
" | Desconto: R$" + [Link]("%.2f", [Link]) + "\n" +
"Status: " + [Link]() +
" | Método: " + metodo + "\n" +
"Emissão: " + [Link]() +
" | Vencimento: " + [Link]();
}
}package model;

import [Link];

public abstract class Funcionario implements IPagamento {

// Atributos básicos
private int id;
private String nome;
private String cpf;
private String email;
private String telefone;
private Date dataContratacao;
private String cargo;
private String departamento;

// Atributos de autenticação
private String login;
private String senha;
private String[] permissoes;

// Construtor completo
public Funcionario(int id, String nome, String cpf, String email,
String telefone, Date dataContratacao,
String cargo, String departamento,
String login, String senha, String[] permissoes) {
[Link] = id;
[Link] = nome;
[Link] = cpf;
[Link] = email;
[Link] = telefone;
[Link] = dataContratacao;
 [Link] = cargo;
[Link] = departamento;
[Link] = login;
[Link] = senha;
[Link] = permissoes;
}

// Implementação de IPagamento
@Override
public boolean processarPagamento(double valor) {
double salarioDevido = [Link]();
return valor >= salarioDevido;
}

@Override
public String gerarComprovante() {
String comprovante = "COMPROVANTE DE PAGAMENTO\n";
comprovante += "Funcionário: " + [Link] + " (ID: " + [Link] + ")\n";
comprovante += "Cargo: " + [Link] + " | Depto: " + [Link] + "\
n";
comprovante += "Valor: R$" + [Link]("%.2f", [Link]())
+ "\n";
comprovante += "Data: " + new Date().toString();
return comprovante;
}

@Override
public String getStatus() {
return "Ativo";
}

// Método abstrato
public abstract double calcularRemuneracao();

// Getters e Setters para todos os atributos

public int getId() {
return id;
}

public void setId(int id) {

[Link] = id;
}

public String getNome() {

return nome;
}

public void setNome(String nome) {

[Link] = nome;
}

public String getCpf() {

return cpf;
}

public void setCpf(String cpf) {

[Link] = cpf;
}
public String getEmail() {
return email;
}

public void setEmail(String email) {

[Link] = email;
}

public String getTelefone() {

return telefone;
}

public void setTelefone(String telefone) {

[Link] = telefone;
}

public Date getDataContratacao() {

return dataContratacao;
}

public void setDataContratacao(Date dataContratacao) {

[Link] = dataContratacao;
}

public String getCargo() {

return cargo;
}

public void setCargo(String cargo) {

[Link] = cargo;
}

public String getDepartamento() {

return departamento;
}

public void setDepartamento(String departamento) {

[Link] = departamento;
}

public String getLogin() {

return login;
}

public void setLogin(String login) {

[Link] = login;
}

public String getSenha() {

return senha;
}

public void setSenha(String senha) {

[Link] = senha;
}

public String[] getPermissoes() {

return permissoes;
}
public void setPermissoes(String[] permissoes) {
[Link] = permissoes;
}

// Método toString completo

@Override
public String toString() {
String info = "Funcionário [ID: " + id + "]\n" +
"Nome: " + nome + "\n" +
"CPF: " + cpf + "\n" +
"Email: " + email + "\n" +
"Telefone: " + telefone + "\n" +
"Cargo: " + cargo + " | Departamento: " + departamento + "\n" +
"Contratado em: " + dataContratacao + "\n" +
"Login: " + login + "\n" +
"Permissões: ";

if (permissoes != null) {
for (String permissao : permissoes) {
info += permissao + " ";
}
}

return info;
}
}package model;

import [Link];

public class FuncionarioAssalariado extends Funcionario {

private double salarioBase;
private double beneficios;

// Construtor atualizado
public FuncionarioAssalariado(int id, String nome, String cpf, String email,
String telefone, Date dataContratacao,
String cargo, String departamento,
String login, String senha, String[] permissoes,
double salarioBase, double beneficios) {
super(id, nome, cpf, email, telefone, dataContratacao, cargo, departamento,
login, senha, permissoes);
[Link] = salarioBase;
[Link] = beneficios;
}

@Override
public double calcularRemuneracao() {
return salarioBase + beneficios;
}

// Getters específicos
public double getSalarioBase() {
return salarioBase;
}

public double getBeneficios() {

return beneficios;
}
}package model;

import [Link];

public class FuncionarioComissionado extends Funcionario {

private double vendasMes;
private double taxaComissao;

// Construtor atualizado
public FuncionarioComissionado(int id, String nome, String cpf, String email,
String telefone, Date dataContratacao,
String cargo, String departamento,
String login, String senha, String[] permissoes,
double vendasMes, double taxaComissao) {
super(id, nome, cpf, email, telefone, dataContratacao, cargo, departamento,
login, senha, permissoes);
[Link] = vendasMes;
[Link] = taxaComissao;
}

@Override
public double calcularRemuneracao() {
return vendasMes * taxaComissao;
}

// Getters específicos
public double getVendasMes() {
return vendasMes;
}

public double getTaxaComissao() {

return taxaComissao;
}
}package model;

import [Link];

public class FuncionarioHorista extends Funcionario {

private double valorHora;
private double horasTrabalhadas;
private boolean recebeAdicionalNoturno;

// Construtor atualizado
public FuncionarioHorista(int id, String nome, String cpf, String email,
String telefone, Date dataContratacao,
String cargo, String departamento,
String login, String senha, String[] permissoes,
double valorHora, double horasTrabalhadas,
boolean recebeAdicionalNoturno) {
super(id, nome, cpf, email, telefone, dataContratacao, cargo, departamento,
login, senha, permissoes);
[Link] = valorHora;
[Link] = horasTrabalhadas;
[Link] = recebeAdicionalNoturno;
}

@Override
public double calcularRemuneracao() {
double salario = valorHora * horasTrabalhadas;
 return recebeAdicionalNoturno ? salario * 1.2 : salario;
}

// Getters específicos
public double getValorHora() {
return valorHora;
}

public double getHorasTrabalhadas() {

return horasTrabalhadas;
}

public boolean isRecebeAdicionalNoturno() {

return recebeAdicionalNoturno;
}
}package model;

public interface IPagamento {

boolean processarPagamento(double valor);
String gerarComprovante();
String getStatus();
}package model;

public class Produto {

private int id;
private String nome;
private String descricao;
private double preco;
private String categoria;
private int quantidadeEstoque;
private int estoqueMinimo;
private String imagemPrincipal;

// Construtor completo
public Produto(int id, String nome, String descricao, double preco,
String categoria, int quantidadeEstoque, int estoqueMinimo,
String imagemPrincipal) {
[Link] = id;
[Link] = nome;
[Link] = descricao;
[Link] = preco;
[Link] = categoria;
[Link] = quantidadeEstoque;
[Link] = estoqueMinimo;
[Link] = imagemPrincipal;
}

// ---- Métodos de Gestão de Estoque ---- //

public void reduzirEstoque(int quantidade) {
if (quantidade > 0 && [Link] >= quantidade) {
[Link] -= quantidade;
}
}

public void aumentarEstoque(int quantidade) {

if (quantidade > 0) {
[Link] += quantidade;
}
}
public boolean precisaRepor() {
return [Link] <= [Link];
}

// ---- Getters e Setters ---- //

public int getId() {
return id;
}

public void setId(int id) {

[Link] = id;
}

public String getNome() {

return nome;
}

public void setNome(String nome) {

[Link] = nome;
}

public String getDescricao() {

return descricao;
}

public void setDescricao(String descricao) {

[Link] = descricao;
}

public double getPreco() {

return preco;
}

public void setPreco(double preco) {

[Link] = preco;
}

public String getCategoria() {

return categoria;
}

public void setCategoria(String categoria) {

[Link] = categoria;
}

public int getQuantidadeEstoque() {

return quantidadeEstoque;
}

public void setQuantidadeEstoque(int quantidadeEstoque) {

[Link] = quantidadeEstoque;
}

public int getEstoqueMinimo() {

return estoqueMinimo;
}

public void setEstoqueMinimo(int estoqueMinimo) {

 [Link] = estoqueMinimo;
}

public String getImagemPrincipal() {

return imagemPrincipal;
}

public void setImagemPrincipal(String imagemPrincipal) {

[Link] = imagemPrincipal;
}

// ---- Métodos Auxiliares ---- //

@Override
public String toString() {
return "Produto{" +
"id=" + id +
", nome='" + nome + '\'' +
", descricao='" + descricao + '\'' +
", preco=" + preco +
", categoria='" + categoria + '\'' +
", quantidadeEstoque=" + quantidadeEstoque +
", estoqueMinimo=" + estoqueMinimo +
", imagemPrincipal='" + imagemPrincipal + '\'' +
'}';
}
}package model;

import [Link];

public class Promocao {

private int id;
private String codigo; // Código único (null para promoções de produto)
private int idProduto; // -1 para cupons gerais
private double valorDesconto;
private boolean isPercentual;
private Date dataInicio;
private Date dataFim;
private boolean ativo;
private String descricao;
private int usosMaximos;
private int usosAtuais;

// Construtor para promoção de produto

public Promocao(int id, int idProduto, double valorDesconto, boolean isPercentual,
Date dataInicio, Date dataFim, String descricao) {
[Link] = id;
[Link] = idProduto;
[Link] = valorDesconto;
[Link] = isPercentual;
[Link] = dataInicio;
[Link] = dataFim;
[Link] = descricao;
[Link] = true;
[Link] = null;
[Link] = 0; // Ilimitado
[Link] = 0;
}

// Construtor para cupom de desconto

public Promocao(int id, String codigo, double valorDesconto, boolean isPercentual,
Date dataInicio, Date dataFim, String descricao, int usosMaximos) {
[Link] = id;
[Link] = codigo;
[Link] = -1; // Cupom geral
[Link] = valorDesconto;
[Link] = isPercentual;
[Link] = dataInicio;
[Link] = dataFim;
[Link] = descricao;
[Link] = true;
[Link] = usosMaximos;
[Link] = 0;
}

// Aplica o desconto e incrementa o contador de usos

public double aplicarDesconto(double valorOriginal) {
if (!podeSerUsada()) {
return valorOriginal;
}

usosAtuais++;
if (isPercentual) {
return valorOriginal * (1 - valorDesconto / 100);
} else {
double resultado = valorOriginal - valorDesconto;
return resultado > 0 ? resultado : 0;
}
}

// Verifica se a promoção/cupom pode ser usada

public boolean podeSerUsada() {
if (!estaAtiva()) {
return false;
}
if (usosMaximos > 0 && usosAtuais >= usosMaximos) {
return false;
}
return true;
}

// Verifica se está no período válido

public boolean estaAtiva() {
Date hoje = new Date();
return ativo &&  && ;
}

// Getters e Setters
public int getId() {
return id;
}

public String getCodigo() {

return codigo;
}

public int getIdProduto() {

return idProduto;
}
public double getValorDesconto() {
return valorDesconto;
}

public boolean isPercentual() {

return isPercentual;
}

public Date getDataInicio() {

return dataInicio;
}

public Date getDataFim() {

return dataFim;
}

public boolean isAtivo() {

return ativo;
}

public void setAtivo(boolean ativo) {

[Link] = ativo;
}

public String getDescricao() {

return descricao;
}

public void setDescricao(String descricao) {

[Link] = descricao;
}

public int getUsosMaximos() {

return usosMaximos;
}

public int getUsosAtuais() {

return usosAtuais;
}

public boolean isCupom() {

return codigo != null;
}
}package model;

import [Link];

public class Venda {

private int id;
private int idCliente;
private Date dataVenda;
private double valorTotal;
private String status;

// Construtor
public Venda(int id, int idCliente, Date dataVenda, double valorTotal, String
status) {
[Link] = id;
 [Link] = idCliente;
[Link] = dataVenda;
[Link] = valorTotal;
[Link] = status;
}

// Getters e Setters
public int getId() {
return id;
}

public void setId(int id) {

[Link] = id;
}

public int getIdCliente() {

return idCliente;
}

public void setIdCliente(int idCliente) {

[Link] = idCliente;
}

public Date getDataVenda() {

return dataVenda;
}

public void setDataVenda(Date dataVenda) {

[Link] = dataVenda;
}

public double getValorTotal() {

return valorTotal;
}

public void setValorTotal(double valorTotal) {

[Link] = valorTotal;
}

public String getStatus() {

return status;
}

public void setStatus(String status) {

[Link] = status;
}
}package [Link];

import [Link];

public interface IRepCliente {

void adicionar(Cliente cliente);
Cliente buscarPorId(int id);
Cliente[] listarTodos();
boolean atualizar(Cliente cliente);
boolean remover(int id);
Cliente[] buscarPorNome(String nome);
}package [Link];
import [Link];

public interface IRepFatura {

void adicionar(Fatura fatura);
Fatura buscarPorId(int id);
Fatura[] listarTodas();
Fatura[] buscarPorCliente(int idCliente);
Fatura[] buscarPorStatus(String status);
boolean atualizar(Fatura fatura);
boolean remover(int id);
int getQuantidade();
}package [Link];

import [Link];
import [Link];
import [Link];
import [Link];

public interface IRepFuncionario {

boolean adicionar(Funcionario funcionario); // Alterado para retornar boolean
Funcionario buscarPorId(int id);
Funcionario[] listarTodos();
boolean atualizar(Funcionario funcionario);
boolean remover(int id);
Funcionario[] buscarPorNome(String nome);
Funcionario[] buscarPorDepartamento(String departamento);
FuncionarioAssalariado[] listarAssalariados();
FuncionarioHorista[] listarHoristas();
FuncionarioComissionado[] listarComissionados();
int getQuantidade();
}package [Link];

import [Link];

public interface IRepProduto {

// ---- MÉTODOS BÁSICOS (CRUD) ---- //
void adicionar(Produto produto);
Produto buscarPorId(int id);
Produto[] listarTodos();
boolean atualizar(Produto produto);
boolean remover(int id);

// ---- MÉTODOS DE BUSCA ---- //

Produto[] buscarPorNome(String nome);
Produto[] buscarPorCategoria(String categoria);
int getQuantidade();

// ---- MÉTODOS DE IMAGENS ---- //

boolean adicionarImagemAoProduto(int idProduto, String caminhoImagem);
boolean removerImagemDoProduto(int idProduto, String caminhoImagem);
boolean definirImagemPrincipal(int idProduto, String caminhoImagem);
String[] listarImagensDoProduto(int idProduto);
String getImagemPrincipalDoProduto(int idProduto);

// ---- MÉTODOS DE ESTOQUE ---- //

boolean atualizarEstoque(int idProduto, int quantidade);
Produto[] listarProdutosComEstoqueBaixo();
}package [Link];
import [Link];
import [Link];

public interface IRepPromocao {

boolean adicionar(Promocao promocao);

Promocao buscarPorId(int id);
Promocao buscarPorCodigo(String codigo);
Promocao[] buscarPorProduto(int idProduto);
Promocao[] buscarAtivas();
Promocao[] buscarExpiradas();
Promocao[] buscarCuponsAtivos();
boolean atualizar(Promocao promocao);
boolean remover(int id);
int getQuantidade();
Promocao[] listarTodos();
}package [Link];

import [Link];

import [Link];

public interface IRepVenda {

void adicionar(Venda venda);
Venda buscarPorId(int id);
Venda[] listarTodos();
Venda[] buscarPorCliente(int idCliente);
Venda[] buscarPorData(Date dataInicio, Date dataFim);
double calcularTotalVendas();
int getQuantidade();
}package repository;

import [Link];
import [Link];

public class RepCliente implements IRepCliente {

private static RepCliente instancia;
private Cliente[] clientes;
private int tamanhoAtual;
private static final int TAMANHO_MAX = 100; // Capacidade máxima

// Construtor privado (Singleton)

private RepCliente() {
clientes = new Cliente[TAMANHO_MAX];
tamanhoAtual = 0;
}

// Método Singleton (thread-safe)

public static synchronized RepCliente getInstancia() {
if (instancia == null) {
instancia = new RepCliente();
}
return instancia;
}

@Override
public void adicionar(Cliente cliente) {
if (tamanhoAtual < TAMANHO_MAX) {
clientes[tamanhoAtual] = cliente;
 tamanhoAtual++;
} else {
[Link]("ERRO: Limite máximo de clientes atingido!");
}
}

@Override
public Cliente buscarPorId(int id) {
for (int i = 0; i < tamanhoAtual; i++) {
if (clientes[i].getId() == id) {
return clientes[i];
}
}
return null;
}

@Override
public Cliente[] listarTodos() {
Cliente[] clientesAtivos = new Cliente[tamanhoAtual];
[Link](clientes, 0, clientesAtivos, 0, tamanhoAtual);
return clientesAtivos;
}

@Override
public boolean atualizar(Cliente cliente) {
for (int i = 0; i < tamanhoAtual; i++) {
if (clientes[i].getId() == [Link]()) {
clientes[i] = cliente;
return true;
}
}
return false;
}

@Override
public boolean remover(int id) {
for (int i = 0; i < tamanhoAtual; i++) {
if (clientes[i].getId() == id) {
// Substitui pelo último elemento e decrementa o tamanho
clientes[i] = clientes[tamanhoAtual - 1];
clientes[tamanhoAtual - 1] = null;
tamanhoAtual--;
return true;
}
}
return false;
}

@Override
public Cliente[] buscarPorNome(String nome) {
int count = 0;
// Conta quantos clientes têm o nome buscado
for (int i = 0; i < tamanhoAtual; i++) {
if (clientes[i].getNome().equalsIgnoreCase(nome)) {
count++;
}
}

if (count == 0) {
 return new Cliente[0]; // Retorna array vazio se não encontrar
}

Cliente[] resultados = new Cliente[count];

int index = 0;
for (int i = 0; i < tamanhoAtual; i++) {
if (clientes[i].getNome().equalsIgnoreCase(nome)) {
resultados[index++] = clientes[i];
}
}
return resultados;
}
}package repository;

import [Link];
import [Link];

public class RepFatura implements IRepFatura {

private static RepFatura instancia;
private Fatura[] faturas;
private int tamanho;
private static final int CAPACIDADE_INICIAL = 100;

private RepFatura() {
faturas = new Fatura[CAPACIDADE_INICIAL];
tamanho = 0;
}

public static synchronized RepFatura getInstancia() {

if (instancia == null) {
instancia = new RepFatura();
}
return instancia;
}

@Override
public void adicionar(Fatura fatura) {
if (tamanho == [Link]) {
aumentarCapacidade();
}
faturas[tamanho] = fatura;
tamanho++;
}

@Override
public Fatura buscarPorId(int id) {
for (int i = 0; i < tamanho; i++) {
if (faturas[i].getId() == id) {
return faturas[i];
}
}
return null;
}

@Override
public Fatura[] listarTodas() {
Fatura[] todasFaturas = new Fatura[tamanho];
for (int i = 0; i < tamanho; i++) {
todasFaturas[i] = faturas[i];
 }
return todasFaturas;
}

@Override
public Fatura[] buscarPorCliente(int idCliente) {
int contador = 0;
for (int i = 0; i < tamanho; i++) {
if (faturas[i].getIdCliente() == idCliente) {
contador++;
}
}

Fatura[] faturasCliente = new Fatura[contador];

int index = 0;
for (int i = 0; i < tamanho; i++) {
if (faturas[i].getIdCliente() == idCliente) {
faturasCliente[index] = faturas[i];
index++;
}
}
return faturasCliente;
}

@Override
public Fatura[] buscarPorStatus(String status) {
int contador = 0;
for (int i = 0; i < tamanho; i++) {
if (faturas[i].getStatus().equalsIgnoreCase(status)) {
contador++;
}
}

Fatura[] faturasStatus = new Fatura[contador];

int index = 0;
for (int i = 0; i < tamanho; i++) {
if (faturas[i].getStatus().equalsIgnoreCase(status)) {
faturasStatus[index] = faturas[i];
index++;
}
}
return faturasStatus;
}

@Override
public boolean atualizar(Fatura fatura) {
for (int i = 0; i < tamanho; i++) {
if (faturas[i].getId() == [Link]()) {
faturas[i] = fatura;
return true;
}
}
return false;
}

@Override
public boolean remover(int id) {
for (int i = 0; i < tamanho; i++) {
if (faturas[i].getId() == id) {
 for (int j = i; j < tamanho - 1; j++) {
faturas[j] = faturas[j + 1];
}
faturas[tamanho - 1] = null;
tamanho--;
return true;
}
}
return false;
}

@Override
public int getQuantidade() {
return tamanho;
}

private void aumentarCapacidade() {

int novaCapacidade = [Link] * 2;
Fatura[] novoArray = new Fatura[novaCapacidade];
for (int i = 0; i < [Link]; i++) {
novoArray[i] = faturas[i];
}
faturas = novoArray;
}

// Método adicional para buscar faturas vencidas

public Fatura[] buscarFaturasVencidas() {
int contador = 0;
for (int i = 0; i < tamanho; i++) {
if (faturas[i].estaVencida()) {
contador++;
}
}

Fatura[] vencidas = new Fatura[contador];

int index = 0;
for (int i = 0; i < tamanho; i++) {
if (faturas[i].estaVencida()) {
vencidas[index] = faturas[i];
index++;
}
}
return vencidas;
}
}package repository;

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class RepFuncionario implements IRepFuncionario {

private static RepFuncionario instancia; // Adicionando Singleton
private Funcionario[] funcionarios;
private int quantidade;
private static final int TAMANHO_MAXIMO = 100;

// Construtor privado para Singleton

private RepFuncionario() {
[Link] = new Funcionario[TAMANHO_MAXIMO];
[Link] = 0;
}

// Método Singleton (thread-safe)

public static synchronized RepFuncionario getInstancia() {
if (instancia == null) {
instancia = new RepFuncionario();
}
return instancia;
}

@Override
public boolean adicionar(Funcionario funcionario) {
if (quantidade >= TAMANHO_MAXIMO) {
[Link]("ERRO: Limite máximo de funcionários atingido (100)");
return false;
}

funcionarios[quantidade] = funcionario;
quantidade++;
return true;
}

@Override
public Funcionario buscarPorId(int id) {
for (int i = 0; i < quantidade; i++) {
if (funcionarios[i].getId() == id) {
return funcionarios[i];
}
}
return null;
}

@Override
public Funcionario[] listarTodos() {
Funcionario[] lista = new Funcionario[quantidade];
for (int i = 0; i < quantidade; i++) {
lista[i] = funcionarios[i];
}
return lista;
}

@Override
public boolean atualizar(Funcionario funcionario) {
for (int i = 0; i < quantidade; i++) {
if (funcionarios[i].getId() == [Link]()) {
funcionarios[i] = funcionario;
return true;
}
}
return false;
}

@Override
public boolean remover(int id) {
for (int i = 0; i < quantidade; i++) {
if (funcionarios[i].getId() == id) {
 // Substitui pelo último elemento
funcionarios[i] = funcionarios[quantidade - 1];
funcionarios[quantidade - 1] = null;
quantidade--;
return true;
}
}
return false;
}

@Override
public Funcionario[] buscarPorNome(String nome) {
int contador = 0;
for (int i = 0; i < quantidade; i++) {
if (funcionarios[i].getNome().equalsIgnoreCase(nome)) {
contador++;
}
}

Funcionario[] resultado = new Funcionario[contador];

int index = 0;
for (int i = 0; i < quantidade; i++) {
if (funcionarios[i].getNome().equalsIgnoreCase(nome)) {
resultado[index++] = funcionarios[i];
}
}
return resultado;
}

@Override
public Funcionario[] buscarPorDepartamento(String departamento) {
int contador = 0;
for (int i = 0; i < quantidade; i++) {
if (funcionarios[i].getDepartamento().equalsIgnoreCase(departamento)) {
contador++;
}
}

Funcionario[] resultado = new Funcionario[contador];

int index = 0;
for (int i = 0; i < quantidade; i++) {
if (funcionarios[i].getDepartamento().equalsIgnoreCase(departamento)) {
resultado[index++] = funcionarios[i];
}
}
return resultado;
}

@Override
public FuncionarioAssalariado[] listarAssalariados() {
int contador = 0;
for (int i = 0; i < quantidade; i++) {
if (funcionarios[i] instanceof FuncionarioAssalariado) {
contador++;
}
}

FuncionarioAssalariado[] assalariados = new FuncionarioAssalariado[contador];

int index = 0;
 for (int i = 0; i < quantidade; i++) {
if (funcionarios[i] instanceof FuncionarioAssalariado) {
assalariados[index++] = (FuncionarioAssalariado) funcionarios[i];
}
}
return assalariados;
}

@Override
public FuncionarioHorista[] listarHoristas() {
int contador = 0;
for (int i = 0; i < quantidade; i++) {
if (funcionarios[i] instanceof FuncionarioHorista) {
contador++;
}
}

FuncionarioHorista[] horistas = new FuncionarioHorista[contador];

int index = 0;
for (int i = 0; i < quantidade; i++) {
if (funcionarios[i] instanceof FuncionarioHorista) {
horistas[index++] = (FuncionarioHorista) funcionarios[i];
}
}
return horistas;
}

@Override
public FuncionarioComissionado[] listarComissionados() {
int contador = 0;
for (int i = 0; i < quantidade; i++) {
if (funcionarios[i] instanceof FuncionarioComissionado) {
contador++;
}
}

FuncionarioComissionado[] comissionados = new

FuncionarioComissionado[contador];
int index = 0;
for (int i = 0; i < quantidade; i++) {
if (funcionarios[i] instanceof FuncionarioComissionado) {
comissionados[index++] = (FuncionarioComissionado) funcionarios[i];
}
}
return comissionados;
}

@Override
public int getQuantidade() {
return quantidade;
}
}package repository;

import [Link];
import [Link];

public class RepProduto implements IRepProduto {

private static RepProduto instancia;
private Produto[] produtos;
private String[][] imagensProdutos; // Array paralelo para imagens
private int tamanhoAtual;
private static final int TAMANHO_MAX = 100;

private RepProduto() {
produtos = new Produto[TAMANHO_MAX];
imagensProdutos = new String[TAMANHO_MAX][10]; // Máximo 10 imagens por produto
tamanhoAtual = 0;
}

public static synchronized RepProduto getInstancia() {

if (instancia == null) {
instancia = new RepProduto();
}
return instancia;
}

// ---- MÉTODOS BÁSICOS ---- //

@Override
public void adicionar(Produto produto) {
if (tamanhoAtual < TAMANHO_MAX) {
produtos[tamanhoAtual] = produto;
tamanhoAtual++;
}
}

@Override
public Produto buscarPorId(int id) {
for (int i = 0; i < tamanhoAtual; i++) {
if (produtos[i].getId() == id) {
return produtos[i];
}
}
return null;
}

@Override
public Produto[] listarTodos() {
Produto[] lista = new Produto[tamanhoAtual];
[Link](produtos, 0, lista, 0, tamanhoAtual);
return lista;
}

@Override
public boolean atualizar(Produto produto) {
for (int i = 0; i < tamanhoAtual; i++) {
if (produtos[i].getId() == [Link]()) {
produtos[i] = produto;
return true;
}
}
return false;
}

@Override
public boolean remover(int id) {
for (int i = 0; i < tamanhoAtual; i++) {
if (produtos[i].getId() == id) {
// Substitui o produto a ser removido pelo último da lista
 produtos[i] = produtos[tamanhoAtual - 1];
imagensProdutos[i] = imagensProdutos[tamanhoAtual - 1];
// Limpa a última posição
produtos[tamanhoAtual - 1] = null;
imagensProdutos[tamanhoAtual - 1] = new String[10];
tamanhoAtual--;
return true;
}
}
return false;
}

// ---- MÉTODOS DE BUSCA ---- //

@Override
public Produto[] buscarPorNome(String nome) {
if (nome == null || [Link]().isEmpty()) {
return new Produto[0];
}

int count = 0;
for (int i = 0; i < tamanhoAtual; i++) {
if (produtos[i].getNome().equalsIgnoreCase(nome)) {
count++;
}
}

Produto[] resultado = new Produto[count];

int index = 0;
for (int i = 0; i < tamanhoAtual; i++) {
if (produtos[i].getNome().equalsIgnoreCase(nome)) {
resultado[index++] = produtos[i];
}
}
return resultado;
}

@Override
public Produto[] buscarPorCategoria(String categoria) {
if (categoria == null || [Link]().isEmpty()) {
return new Produto[0];
}

int count = 0;
for (int i = 0; i < tamanhoAtual; i++) {
if (produtos[i].getCategoria().equalsIgnoreCase(categoria)) {
count++;
}
}

Produto[] resultado = new Produto[count];

int index = 0;
for (int i = 0; i < tamanhoAtual; i++) {
if (produtos[i].getCategoria().equalsIgnoreCase(categoria)) {
resultado[index++] = produtos[i];
}
}
return resultado;
}
@Override
public int getQuantidade() {
return tamanhoAtual;
}

// ---- MÉTODOS DE IMAGENS ---- //

@Override
public boolean adicionarImagemAoProduto(int idProduto, String caminhoImagem) {
if (caminhoImagem == null || [Link]().isEmpty()) {
return false;
}

for (int i = 0; i < tamanhoAtual; i++) {

if (produtos[i].getId() == idProduto) {
for (int j = 0; j < imagensProdutos[i].length; j++) {
if (imagensProdutos[i][j] == null) {
imagensProdutos[i][j] = caminhoImagem;
return true;
}
}
}
}
return false;
}

@Override
public boolean removerImagemDoProduto(int idProduto, String caminhoImagem) {
if (caminhoImagem == null || [Link]().isEmpty()) {
return false;
}

for (int i = 0; i < tamanhoAtual; i++) {

if (produtos[i].getId() == idProduto) {
if (produtos[i].getImagemPrincipal().equals(caminhoImagem)) {
return false; // Não permite remover imagem principal
}

for (int j = 0; j < imagensProdutos[i].length; j++) {

if ([Link](imagensProdutos[i][j])) {
imagensProdutos[i][j] = null;
return true;
}
}
}
}
return false;
}

@Override
public boolean definirImagemPrincipal(int idProduto, String caminhoImagem) {
if (caminhoImagem == null || [Link]().isEmpty()) {
return false;
}

for (int i = 0; i < tamanhoAtual; i++) {

if (produtos[i].getId() == idProduto) {
for (int j = 0; j < imagensProdutos[i].length; j++) {
if ([Link](imagensProdutos[i][j])) {
produtos[i].setImagemPrincipal(caminhoImagem);
 return true;
}
}
}
}
return false;
}

@Override
public String[] listarImagensDoProduto(int idProduto) {
for (int i = 0; i < tamanhoAtual; i++) {
if (produtos[i].getId() == idProduto) {
int count = 0;
for (int j = 0; j < imagensProdutos[i].length; j++) {
if (imagensProdutos[i][j] != null) {
count++;
}
}

String[] imagens = new String[count];

int index = 0;
for (int j = 0; j < imagensProdutos[i].length; j++) {
if (imagensProdutos[i][j] != null) {
imagens[index++] = imagensProdutos[i][j];
}
}
return imagens;
}
}
return new String[0];
}

@Override
public String getImagemPrincipalDoProduto(int idProduto) {
Produto p = buscarPorId(idProduto);
return (p != null) ? [Link]() : null;
}

// ---- MÉTODOS DE ESTOQUE ---- //

@Override
public boolean atualizarEstoque(int idProduto, int quantidade) {
Produto produto = buscarPorId(idProduto);
if (produto != null) {
if (quantidade > 0) {
[Link](quantidade);
} else {
[Link](-quantidade);
}
return true;
}
return false;
}

@Override
public Produto[] listarProdutosComEstoqueBaixo() {
int count = 0;
for (int i = 0; i < tamanhoAtual; i++) {
if (produtos[i].precisaRepor()) {
count++;
 }
}

Produto[] produtosComAlerta = new Produto[count];

int index = 0;
for (int i = 0; i < tamanhoAtual; i++) {
if (produtos[i].precisaRepor()) {
produtosComAlerta[index++] = produtos[i];
}
}
return produtosComAlerta;
}
}package repository;

import [Link];
import [Link];
import [Link];

public class RepPromocao implements IRepPromocao {

private static RepPromocao instancia;
private Promocao[] promocoes;
private int tamanho;
private static final int CAPACIDADE_INICIAL = 100;

private RepPromocao() {
promocoes = new Promocao[CAPACIDADE_INICIAL];
tamanho = 0;
}

public static synchronized RepPromocao getInstancia() {

if (instancia == null) {
instancia = new RepPromocao();
}
return instancia;
}

@Override
public boolean adicionar(Promocao promocao) {
if (tamanho >= [Link]) {
aumentarCapacidade();
}

// Verifica se já existe promoção/cupom com mesmo código

if ([Link]() && buscarPorCodigo([Link]()) != null) {
return false;
}

promocoes[tamanho] = promocao;
tamanho++;
return true;
}

@Override
public Promocao buscarPorId(int id) {
for (int i = 0; i < tamanho; i++) {
if (promocoes[i].getId() == id) {
return promocoes[i];
}
}
 return null;
}

@Override
public Promocao buscarPorCodigo(String codigo) {
if (codigo == null) return null;

for (int i = 0; i < tamanho; i++) {

if (promocoes[i].isCupom() && [Link](promocoes[i].getCodigo())) {
return promocoes[i];
}
}
return null;
}

@Override
public Promocao[] buscarPorProduto(int idProduto) {
int count = 0;
for (int i = 0; i < tamanho; i++) {
if (promocoes[i].getIdProduto() == idProduto && !promocoes[i].isCupom()) {
count++;
}
}

Promocao[] resultado = new Promocao[count];

int index = 0;
for (int i = 0; i < tamanho; i++) {
if (promocoes[i].getIdProduto() == idProduto && !promocoes[i].isCupom()) {
resultado[index++] = promocoes[i];
}
}
return resultado;
}

@Override
public Promocao[] buscarAtivas() {
Date hoje = new Date();
int count = 0;

for (int i = 0; i < tamanho; i++) {

if (promocoes[i].estaAtiva()) {
count++;
}
}

Promocao[] ativas = new Promocao[count];

int index = 0;
for (int i = 0; i < tamanho; i++) {
if (promocoes[i].estaAtiva()) {
ativas[index++] = promocoes[i];
}
}
return ativas;
}

@Override
public Promocao[] buscarExpiradas() {
Date hoje = new Date();
int count = 0;
 for (int i = 0; i < tamanho; i++) {
if (!promocoes[i].estaAtiva()) {
count++;
}
}

Promocao[] expiradas = new Promocao[count];

int index = 0;
for (int i = 0; i < tamanho; i++) {
if (!promocoes[i].estaAtiva()) {
expiradas[index++] = promocoes[i];
}
}
return expiradas;
}

@Override
public Promocao[] buscarCuponsAtivos() {
Date hoje = new Date();
int count = 0;

for (int i = 0; i < tamanho; i++) {

if (promocoes[i].isCupom() && promocoes[i].estaAtiva()) {
count++;
}
}

Promocao[] cupons = new Promocao[count];

int index = 0;
for (int i = 0; i < tamanho; i++) {
if (promocoes[i].isCupom() && promocoes[i].estaAtiva()) {
cupons[index++] = promocoes[i];
}
}
return cupons;
}

@Override
public boolean atualizar(Promocao promocao) {
for (int i = 0; i < tamanho; i++) {
if (promocoes[i].getId() == [Link]()) {
promocoes[i] = promocao;
return true;
}
}
return false;
}

@Override
public boolean remover(int id) {
for (int i = 0; i < tamanho; i++) {
if (promocoes[i].getId() == id) {
// Move o último elemento para a posição removida
promocoes[i] = promocoes[tamanho - 1];
promocoes[tamanho - 1] = null;
tamanho--;
return true;
}
 }
return false;
}

@Override
public int getQuantidade() {
return tamanho;
}

@Override
public Promocao[] listarTodos() {
Promocao[] todas = new Promocao[tamanho];
[Link](promocoes, 0, todas, 0, tamanho);
return todas;
}

private void aumentarCapacidade() {

int novaCapacidade = [Link] * 2;
Promocao[] novoArray = new Promocao[novaCapacidade];
[Link](promocoes, 0, novoArray, 0, [Link]);
promocoes = novoArray;
}
}package repository;

import [Link];
import [Link];
import [Link];

public class RepVenda implements IRepVenda {

private static RepVenda instancia;
private Venda[] vendas;
private int tamanhoAtual;
private static final int TAMANHO_MAX = 1000;

private RepVenda() {
vendas = new Venda[TAMANHO_MAX];
tamanhoAtual = 0;
}

public static synchronized RepVenda getInstancia() {

if (instancia == null) {
instancia = new RepVenda();
}
return instancia;
}

@Override
public void adicionar(Venda venda) {
if (tamanhoAtual < TAMANHO_MAX) {
vendas[tamanhoAtual] = venda;
tamanhoAtual++;
} else {
[Link]("ERRO: Limite máximo de vendas atingido!");
}
}

@Override
public Venda buscarPorId(int id) {
for (int i = 0; i < tamanhoAtual; i++) {
 if (vendas[i].getId() == id) {
return vendas[i];
}
}
return null;
}

@Override
public Venda[] listarTodos() {
Venda[] todasVendas = new Venda[tamanhoAtual];
[Link](vendas, 0, todasVendas, 0, tamanhoAtual);
return todasVendas;
}

@Override
public Venda[] buscarPorCliente(int idCliente) {
int count = 0;
for (int i = 0; i < tamanhoAtual; i++) {
if (vendas[i].getIdCliente() == idCliente) {
count++;
}
}

Venda[] vendasCliente = new Venda[count];

int index = 0;
for (int i = 0; i < tamanhoAtual; i++) {
if (vendas[i].getIdCliente() == idCliente) {
vendasCliente[index++] = vendas[i];
}
}
return vendasCliente;
}

@Override
public Venda[] buscarPorData(Date dataInicio, Date dataFim) {
int count = 0;
for (int i = 0; i < tamanhoAtual; i++) {
Date dataVenda = vendas[i].getDataVenda();
if ( && ) {
count++;
}
}

Venda[] vendasPeriodo = new Venda[count];

int index = 0;
for (int i = 0; i < tamanhoAtual; i++) {
Date dataVenda = vendas[i].getDataVenda();
if ( && ) {
vendasPeriodo[index++] = vendas[i];
}
}
return vendasPeriodo;
}

@Override
public double calcularTotalVendas() {
double total = 0.0;
for (int i = 0; i < tamanhoAtual; i++) {
total += vendas[i].getValorTotal();
 }
return total;
}

@Override
public int getQuantidade() {
return tamanhoAtual;
}
}

package [Link];

import model.*;
import controller.*;
import [Link];

public class Main {

public static void main(String[] args) {
// Teste do Controlador de Acesso
testarControladorAcesso();

// Teste do Controlador de Cliente

testarControladorCliente();

// Teste do Controlador de Produto

testarControladorProduto();

// Teste do Controlador de Promoções

testarControladorPromocoes();

// Teste do Controlador de Funcionários

testarControladorFuncionario();

// Teste do Controlador de Vendas e Carrinho

testarControladorVendaECarrinho();

// Teste do Controlador de Fatura e Pagamento

testarControladorFaturaEPagamento();
}

private static void testarControladorAcesso() {

[Link]("\n=== TESTE CONTROLADOR DE ACESSO ===");

ControladorAcesso controladorAcesso = [Link]();

// Criar alguns funcionários para teste

Funcionario func1 = new FuncionarioAssalariado(
1, "Admin", "111.111.111-11", "admin@[Link]",
"(11) 1111-1111", new Date(), "Gerente", "TI",
"admin", "admin123", new String[]{"admin", "gerente"},
5000, 1000
);

Funcionario func2 = new FuncionarioHorista(

2, "Vendedor", "222.222.222-22", "vendedor@[Link]",
"(22) 2222-2222", new Date(), "Vendedor", "Vendas",
"vendedor", "venda123", new String[]{"vendas"},
50, 160, false
);
 [Link]().contratarFuncionario(func1);
[Link]().contratarFuncionario(func2);

// Testar autenticação
[Link]("Autenticação admin (deve ser true): " +
[Link]("admin", "admin123"));
[Link]("Autenticação inválida (deve ser false): " +
[Link]("admin", "senhaerrada"));

// Testar permissões
[Link]("Permissão admin (deve ser true): " +
[Link](1, "admin"));
[Link]("Permissão inexistente (deve ser false): " +
[Link](2, "admin"));
}

private static void testarControladorCliente() {

[Link]("\n=== TESTE CONTROLADOR DE CLIENTE ===");

ControladorCliente controladorCliente = [Link]();

// Cadastrar clientes
Cliente cliente1 = new Cliente(
1, "João Silva", "joao@[Link]", "senha123",
"Rua A, 123", "(11) 9999-9999");
Cliente cliente2 = new Cliente(
2, "Maria Souza", "maria@[Link]", "abc456",
"Av. B, 456", "(11) 8888-8888");

[Link](cliente1);
[Link](cliente2);

// Testar autenticação
[Link]("Autenticação cliente 1 (deve ser true): " +
[Link](1, "senha123"));
[Link]("Autenticação inválida (deve ser false): " +
[Link](1, "senhaerrada"));

// Buscar cliente
[Link]("Buscar cliente 1: " +
[Link](1));
[Link]("Buscar cliente inexistente: " +
[Link](99));
}

private static void testarControladorProduto() {

[Link]("\n=== TESTE CONTROLADOR DE PRODUTO ===");

ControladorProduto controladorProduto = [Link]();

// Cadastrar produtos
Produto produto1 = new Produto(
1, "Notebook", "Notebook i7 16GB", 4500.00,
"Eletrônicos", 10, 2, "[Link]");
Produto produto2 = new Produto(
2, "Mouse", "Mouse sem fio", 120.00,
"Acessórios", 50, 10, "[Link]");
Produto produto3 = new Produto(
 3, "Teclado", "Teclado mecânico", 350.00,
"Acessórios", 30, 5, "[Link]");

[Link](produto1);
[Link](produto2);
[Link](produto3);

// Listar produtos
[Link]("\nTodos os produtos:");
for (Produto p : [Link]()) {
[Link](p);
}

// Buscar por categoria

[Link]("\nProdutos da categoria Acessórios:");
for (Produto p :
[Link]("Acessórios")) {
[Link]([Link]() + " - R$" + [Link]());
}

// Testar estoque
[Link]("\nVerificar estoque produto 1:");
[Link]([Link](1));

// Registrar venda
[Link](1, 2);
[Link]("\nEstoque após venda de 2 notebooks:");
[Link]([Link](1));

// Emitir alertas de estoque

[Link]("\nAlertas de estoque:");
[Link]();
}

private static void testarControladorPromocoes() {

[Link]("\n=== TESTE CONTROLADOR DE PROMOÇÕES ===");

ControladorPromocoes controladorPromocoes =
[Link]();
Date hoje = new Date();
Date amanha = new Date([Link]() + 86400000); // +1 dia
Date semanaQueVem = new Date([Link]() + 86400000 * 7);

// Criar promoção para produto

[Link](
1, 10.0, true, hoje, semanaQueVem, "Promoção de notebook");

// Criar cupom de desconto

[Link](
"CUPOM10", 10.0, true, hoje, semanaQueVem, "Cupom 10%", 100);

// Listar promoções ativas

[Link]("Promoções ativas para produto 1:");
for (Promocao p : [Link](1)) {
[Link]([Link]() + " - " + [Link]() +
"%");
}

// Testar cupom
 double valorOriginal = 1000.0;
double valorComDesconto = [Link](valorOriginal,
"CUPOM10");
[Link]("\nAplicar cupom:");
[Link]("Original: R$" + valorOriginal);
[Link]("Com desconto: R$" + valorComDesconto);

// Validar cupom
[Link]("\nCupom CUPOM10 é válido? " +
[Link]("CUPOM10"));
}

private static void testarControladorFuncionario() {

[Link]("\n=== TESTE CONTROLADOR DE FUNCIONÁRIO ===");

ControladorFuncionario controladorFuncionario =
[Link]();

// Criar funcionários de diferentes tipos

FuncionarioAssalariado assalariado = new FuncionarioAssalariado(
3, "Carlos", "333.333.333-33", "carlos@[Link]",
"(33) 3333-3333", new Date(), "Gerente", "Vendas",
"carlos", "carlos123", new String[]{"vendas", "gerente"},
6000, 500);

FuncionarioHorista horista = new FuncionarioHorista(

4, "Ana", "444.444.444-44", "ana@[Link]",
"(44) 4444-4444", new Date(), "Atendente", "RH",
"ana", "ana123", new String[]{"rh"},
40, 180, true);

FuncionarioComissionado comissionado = new FuncionarioComissionado(

5, "Pedro", "555.555.555-55", "pedro@[Link]",
"(55) 5555-5555", new Date(), "Vendedor", "Vendas",
"pedro", "pedro123", new String[]{"vendas"},
50000, 0.1);

[Link](assalariado);
[Link](horista);
[Link](comissionado);

// Listar todos os funcionários

[Link]("Todos os funcionários:");
[Link]();

// Listar por departamento

[Link]("\nFuncionários do departamento Vendas:");
[Link]("Vendas");

// Calcular salários
[Link]("\nCálculo de salários:");
[Link]("Salário assalariado: R$" +
[Link](3));
[Link]("Salário horista: R$" +
[Link](4));
[Link]("Salário comissionado: R$" +
[Link](5));
}
 private static void testarControladorVendaECarrinho() {
[Link]("\n=== TESTE CONTROLADOR DE VENDA E CARRINHO ===");

ControladorCarrinho controladorCarrinho =
[Link]();
ControladorVenda controladorVenda = [Link]();

// Adicionar itens ao carrinho

[Link](1); // Notebook
[Link](2); // Mouse
[Link](3); // Teclado

// Calcular total
double total = [Link]();
[Link]("Total do carrinho: R$" + total);

// Aplicar cupom
double totalComDesconto = [Link]()
.aplicarCupom(total, "CUPOM10");
[Link]("Total com desconto: R$" + totalComDesconto);

// Registrar venda
Venda venda = new Venda(
1, 1, new Date(), totalComDesconto, "Concluída");
[Link](venda);

// Gerar relatório
Date hoje = new Date();
Date ontem = new Date([Link]() - 86400000);
double totalVendas = [Link](ontem, hoje);
[Link]("Total de vendas no período: R$" + totalVendas);
}

private static void testarControladorFaturaEPagamento() {

[Link]("\n=== TESTE CONTROLADOR DE FATURA E PAGAMENTO ===");

ControladorFatura controladorFatura = [Link]();

ControladorPagamento controladorPagamento =
[Link]();

// Criar fatura
Fatura fatura = new Fatura(
1, 1, 1, 1000.0, new Date(),
new Date([Link]() + 86400000 * 7),
"Fatura teste");

[Link](fatura);

// Processar pagamento (simulado)

IPagamento pagamento = new IPagamento() {
@Override
public boolean processarPagamento(double valor) {
[Link]("Processando pagamento de R$" + valor);
return true;
}

@Override
public String gerarComprovante() {
return "Comprovante de pagamento simulado";
 }

@Override
public String getStatus() {
return "Aprovado";
}
};

boolean sucesso = [Link](

pagamento, fatura, "Cartão de Crédito");

[Link]("Pagamento processado com sucesso? " + sucesso);

[Link]("Status da fatura: " + [Link]());
}
}