<!DOCTYPE html>
<html lang="pt-BR">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Planificação Econômica Democrática com Otimização</title>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/mathjs/11.10.1/math.js"></script>
	<script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script>
    <style>
        
		body {
    margin: 0;
    position: relative;
}

body::before {
    content: "";
    position: fixed;
    top: 0;
    left: 0;
    width: 100%;
    height: 100%;
    background: url('https://i.postimg.cc/mkZcFJ6g/backgroundcibercomunismo-0-NHja4-Lah-transformed.jpg') no-repeat center center fixed;
    background-size: cover;
    z-index: -1; /* Garante que o fundo fique atrás de todo o conteúdo */
    animation: pulse-brightness 30s infinite;
}
		
		@keyframes pulse-brightness {
			0%, 100% {
				filter: brightness(0.9); /* Brilho normal */
			}
			50% {
				filter: brightness(1.7); /* Brilho aumentado */
			}
		}
		
        h1, h2 {
		color: #333;
		display: flex;
		align-items: center; /* Centraliza verticalmente */
		}
        
		
		table {
    background-color: rgba(100, 0, 0, 0.6) !important; /* Fundo vermelho escuro semi-transparente */
    color: white !important; /* Texto branco para contraste */
    border-collapse: collapse; /* Mescla bordas */
    width: 100%; /* Garante que a tabela ocupe toda a largura disponível */
    margin-top: 20px; /* Espaçamento superior */
}

th, td {
    background-color: rgba(100, 0, 0, 0.5) !important; /* Fundo mais transparente para células */
    color: white !important; /* Texto branco */
    border: 1px solid rgba(255, 255, 255, 0.6); /* Bordas brancas semi-transparentes */
    padding: 8px; /* Espaçamento interno */
    text-align: center; /* Centraliza o texto */
}

th {
    background-color: rgba(100, 0, 0, 0.7) !important; /* Fundo menos transparente para cabeçalhos */
}

        
		
		
		button { padding: 10px 20px; margin: 10px 0; background-color: #007bff; color: white; border: none; cursor: pointer; }
        button:hover { background-color: #0056b3; }
        input[type="number"] { width: 80px; }
        input[type="text"] { width: 100%; }
        .demand-field { display: flex; align-items: center; margin-bottom: 10px; }
        .demand-field label { margin-right: 10px; font-weight: bold; }
        .modal { display: none; position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: rgba(0, 0, 0, 0.5); }
        .modal-content { background-color: white; margin: 10% auto; padding: 20px; width: 400px; border-radius: 8px; }
        
		/* Estilo do modal de boas-vindas */
.modal {
    display: none; /* Inicialmente escondido */
    position: fixed;
    z-index: 1050;
    left: 0;
    top: 0;
    width: 100%;
    height: 100%;
    background-color: rgba(0, 0, 0, 0.8); /* Fundo escuro semi-transparente */
    display: flex;
    justify-content: center;
    align-items: center;
    overflow-y: auto; /* Permite rolagem vertical em telas pequenas */
}

/* Estilo geral das janelas modais */
.modal-content {
    background-color: #333; /* Cor de fundo */
    color: white; /* Cor do texto */
    border-radius: 8px;
    max-width: 90%; /* Largura máxima para telas pequenas */
    max-height: 90%; /* Altura máxima para telas pequenas */
    overflow-y: auto; /* Permite rolagem interna se necessário */
    position: relative; /* Necessário para posicionar elementos internos */
    box-shadow: 0 8px 16px rgba(0, 0, 0, 0.6); /* Sombra estilosa para efeito de profundidade */
}

/* Barra de título da janela */
.modal-title-bar {
    display: flex;
    align-items: center;
    justify-content: flex-start; /* Garante que o título fique alinhado à esquerda */
    background-color: rgba(100, 0, 0, 0.8); /* Cor de fundo atual */
    padding: 10px 15px;
    border-top-left-radius: 8px; /* Arredonda o canto superior esquerdo */
    border-top-right-radius: 8px; /* Arredonda o canto superior direito */
    font-size: 16px;
    font-weight: bold;
    color: white;
}

.modal-title-bar img {
    height: 1em; /* Alinha o tamanho da imagem ao tamanho do texto */
    margin-right: 10px; /* Espaço entre a imagem e o título */
}


/* Botão fechar na barra de título */
.modal-title-bar .close {
    background: none; /* Sem fundo padrão */
    border: none;
    font-size: 18px;
    color: white; /* Cor do texto */
    cursor: pointer;
    margin-right: 10px; /* Adiciona espaçamento à direita */
    padding: 5px; /* Adiciona um espaçamento interno para melhorar o clique */
    border-radius: 3px; /* Torna as bordas do quadrado levemente arredondadas */
}

.modal-title-bar .close:hover {
    background-color: rgba(255, 0, 0, 0.2); /* Fundo vermelho claro ao passar o mouse */
    color: white; /* Mantém o texto branco */
}



.welcome-image {
    display: block; /* Garante que o GIF seja tratado como um bloco */
    margin: 0 auto; /* Centraliza o GIF horizontalmente */
    max-width: 100%; /* Ajusta o tamanho do GIF a telas pequenas */
    height: auto; /* Mantém a proporção do GIF */
}

/* Estilo geral do botão fechar */
.modal-content .close {
    background: none; /* Sem fundo padrão */
    border: none;
    font-size: 18px;
    color: white; /* Cor do texto */
    cursor: pointer;
    margin-right: 10px; /* Espaçamento à direita */
    padding: 5px; /* Espaçamento interno */
    border-radius: 3px; /* Bordas arredondadas */
    position: absolute; /* Garante o posicionamento correto */
    top: 10px; /* Posiciona na parte superior */
    right: 15px; /* Posiciona à direita */
}

/* Efeito de hover para qualquer botão fechar */
.modal-content .close:hover {
    background-color: rgba(255, 0, 0, 0.2); /* Fundo vermelho claro ao passar o mouse */
    color: white; /* Mantém o texto branco */
}

		
		
		/* Estilo geral para fontes e cor de texto */
body {
    font-family: 'Courier New', Courier, monospace;
    color: white; /* Define o texto geral como branco */
    font-weight: bold;
}

/* Estilo para todas as tabelas */
table {
    background-color: rgba(100, 0, 0, 0.8); /* Fundo vermelho ainda mais escuro e menos transparente */
    color: white; /* Define o texto das tabelas como branco */
    border: 1px solid rgba(255, 255, 255, 0.6); /* Borda branca transparente */
    font-weight: bold;
}

th, td {
    background-color: rgba(100, 0, 0, 0.8); /* Fundo vermelho ainda mais escuro e menos transparente */
    color: white; /* Define o texto das células como branco */
    border: 1px solid rgba(255, 255, 255, 0.6);
    padding: 8px;
    font-weight: bold;
}

/* Ajuste da seção "Tamanho da Economia" */
.config-section {
    padding: 20px;
    background-color: rgba(100, 0, 0, 0.8);
    border: 1px solid rgba(255, 255, 255, 0.6);
    border-radius: 8px;
    margin-bottom: 20px;
}

/* Centralização dos campos e do globo */
/* Ajuste da seção "Tamanho da Economia" */
.config-section {
    padding: 20px;
    background-color: rgba(100, 0, 0, 0.8);
    border: 1px solid rgba(255, 255, 255, 0.6);
    border-radius: 8px;
    margin-bottom: 20px;
    display: flex; /* Usando flexbox para alinhar a seção e o globo lado a lado */
    flex-wrap: wrap; /* Permite que o conteúdo se ajuste no layout */
    justify-content: flex-start; /* Alinha os itens à esquerda */
    gap: 20px; /* Espaço entre os elementos da seção */
}

/* Centralização dos campos */
.config-fields {
    flex: 1;
    display: flex;
    flex-direction: column;
    gap: 10px; /* Espaçamento entre os campos */
}

/* Título "Tamanho da Economia" */
.config-section h2 {
    text-align: center; /* Centraliza o título horizontalmente */
    margin-bottom: 20px; /* Espaçamento abaixo do título */
    width: 100%; /* Título ocupa toda a largura */
}

/* Garantir que o globo e a seção se ajustem sem sobreposição */
.config-content {
    display: flex;
    align-items: center; /* Alinha o globo e os campos verticalmente */
    justify-content: flex-start; /* Garante que o conteúdo da seção seja ajustado antes do globo */
    gap: 20px; /* Espaçamento entre a seção e o globo */
    width: 100%; /* Ajuste a largura para garantir que a seção ocupe toda a área */
}

/* Títulos em branco */
h1, h2 {
    background-color: rgba(100, 0, 0, 0.8); /* Fundo vermelho ainda mais escuro e menos transparente */
    color: white; /* Define os títulos como brancos */
    padding: 10px;
    border-radius: 5px;
    font-weight: bold;
}



/* Estilo para todos os campos de entrada, botões e seletores */
input[type="number"], input[type="text"], input[type="checkbox"], select, button {
    background-color: rgba(100, 0, 0, 0.8); /* Fundo vermelho ainda mais escuro e menos transparente */
    color: white; /* Define o texto dos campos e botões como branco */
    border: 1px solid rgba(255, 255, 255, 0.6);
    font-family: 'Courier New', Courier, monospace;
    padding: 5px;
    font-weight: bold;
}

/* Para esconder as modais de otimização */
#optimizationModal, #optimizationResultModal {
    display: none; /* Inicialmente escondido */
    position: fixed;
    z-index: 1050;
    left: 0;
    top: 0;
    width: 100%;
    height: 100%;
    background-color: rgba(0, 0, 0, 0.8); /* Fundo escuro semi-transparente */
    justify-content: center;
    align-items: center;
}


/* Estilo da imagem de boas-vindas */
.welcome-image {
    width: 100%;
    max-width: 300px;
    margin-bottom: 15px;
}

#welcomeModal .modal-content {
    background-color: white; /* Fundo branco */
    color: black; /* Texto preto para contraste */
}

	.info-bar {
    background-color: rgba(100, 0, 0, 0.8); /* Fundo vermelho transparente */
    color: white;
    font-family: 'Courier New', Courier, monospace;
    font-weight: bold;
    padding: 10px 15px;
    position: fixed;
    top: 0;
    left: 0;
    width: 100%;
    z-index: 1000;
    box-shadow: 0 8px 16px rgba(0, 0, 0, 0.6);
    display: flex;
    flex-direction: column;
    gap: 10px;
}

.news-ticker {
    display: flex;
    align-items: center; /* Alinha verticalmente o texto e a imagem */
    justify-content: space-between; /* Espaça o texto e o ícone */
    white-space: nowrap;
    overflow: hidden; /* Impede o conteúdo de transbordar */
    padding-right: 35px; /* Adiciona espaço à direita do contêiner */
    box-sizing: border-box; /* Garante que o padding seja incluído nas dimensões totais */
}


#newsMarquee {
    flex-grow: 1; /* Faz o texto ocupar o máximo de espaço disponível */
}

.ticker-icon {
    height: 1.5em; /* Ajusta o tamanho da imagem */
    max-width: 50px; /* Limita a largura máxima do ícone */
    margin-left: 10px; /* Espaço entre o texto e a imagem */
    margin-right: 0; /* Remove margens adicionais se necessário */
    vertical-align: middle;
}





/* Linha com o GIF e o texto */
.info-row {
    display: flex;
    align-items: center; /* Alinha verticalmente o texto e o GIF */
    gap: 10px; /* Espaçamento entre o GIF e o texto */
}

/* Estilo do texto com localização e hora */
#infoText {
    font-size: 18px;
}

/* Estilo do GIF */
.info-gif {
    height: 2em; /* Ajuste proporcional ao tamanho do texto */
    vertical-align: middle;
}

/* Letreiro de notícias */
#newsTicker {
    overflow: visible; /* Garante que nada seja cortado */
    height: auto; /* Ajusta a altura automaticamente */
    padding-top: 5px; /* Espaço extra acima do texto/imagem */
    display: flex; /* Habilita flexbox para centralização */
    align-items: flex-end;
}

#newsTicker img {
    height: 1.7em; /* Mesmo tamanho do texto do letreiro */
    vertical-align: middle; /* Alinha verticalmente com o texto */
    margin-right: 1px; /* Espaço entre a imagem e o texto */
	transform: translateY(-1px); /* Move a imagem 5 pixels para cima */
}

		#successBox {
    position: fixed;
    top: -50px; /* Começa fora da tela */
    left: 50%;
    transform: translateX(-50%);
    background-color: rgba(0, 255, 0, 0.8); /* Fundo verde transparente */
    color: white;
    padding: 10px 20px;
    border-radius: 5px;
    font-size: 16px;
    font-weight: bold;
    text-align: center;
    opacity: 0; /* Transparente inicialmente */
    transition: top 0.5s ease, opacity 0.5s ease; /* Animações */
    z-index: 2000;
}

.welcome-ticker {
    overflow: hidden; /* Esconde o conteúdo que transborda */
    white-space: nowrap; /* Impede quebra de linha */
    box-sizing: border-box;
    width: 100%; /* Ajusta à largura do modal */
    font-size: 1.5em; /* Tamanho do texto */
    color: black; /* Cor do texto */
    background-color: rgba(255, 255, 255, 0.8); /* Fundo branco semi-transparente */
    padding: 10px; /* Espaçamento interno */
}

.welcome-ticker span {
    display: inline-block;
    animation: scroll-text 10s linear infinite; /* Aplica a animação */
}

@keyframes scroll-text {
    0% {
        transform: translateX(100%); /* Começa fora da tela, à direita */
    }
    100% {
        transform: translateX(-100%); /* Sai fora da tela, à esquerda */
    }
}

#globeContainer.logged-in {
    width: 300px;
    height: 300px;
    position: relative; /* Relativo ao contêiner pai */
    margin-left: 20px; /* Espaçamento entre a seção e o globo */
    display: flex;
    justify-content: center;
    align-items: center;
    float: right; /* Alinha o globo à direita */
    z-index: 1; /* Manter o globo no topo, sem esconder a seção */
}

#globeContainer {
    width: 300px;
    height: 300px;
    position: relative; /* Relativo ao contêiner pai */
    margin-left: auto; /* Centraliza horizontalmente */
    margin-right: auto; /* Centraliza horizontalmente */
    display: block; /* Garante que o contêiner se comporte como bloco */
    z-index: 1;
}

/* Estilo geral para os campos de entrada */
input[type="text"], input[type="password"] {
    background-color: rgba(100, 0, 0, 0.8); /* Fundo vermelho escuro translúcido */
    color: white; /* Texto branco */
    border: 1px solid rgba(255, 255, 255, 0.6); /* Borda branca translúcida */
    padding: 5px;
    font-family: 'Courier New', Courier, monospace;
    font-weight: bold;
}

/* Placeholder com tom de cinza mais claro */
input[type="text"]::placeholder, input[type="password"]::placeholder {
    color: rgba(200, 200, 200, 0.7); /* Cinza claro translúcido */
    font-style: italic; /* Texto em itálico */
}

/* Alterações ao focar no campo */
input[type="text"]:focus, input[type="password"]:focus {
    outline: none; /* Remove o contorno padrão */
    background-color: rgba(100, 0, 0, 0.9); /* Fundo mais opaco ao focar */
    border: 1px solid rgba(255, 255, 255, 0.8); /* Borda mais clara ao focar */
}	
	
    </style>
</head>
<body>

	<div id="welcomeModal" class="modal">
		<div class="modal-content">
			<div class="modal-title-bar">
				<img src="https://i.postimg.cc/TPhm79zs/pngwing-com-8.png" alt="Ícone de estrela">
				<span>Planificação Econômica Democrática e com Otimização</span>
				&nbsp;<img src="https://i.postimg.cc/TPhm79zs/pngwing-com-8.png" alt="Ícone de estrela">
				<button class="close" onclick="closeWelcomeModal()">&times;</button>
			</div>
			<br>
			<img src="https://s11.gifyu.com/images/Syrzl.gif" alt="Imagem de boas-vindas" class="welcome-image">
			<h2>Bem-Vindo à Ditadura do Proletariado, Companheiro!</h2>
			<div id="welcomeTicker" class="welcome-ticker">
				<span>É hora de arrumarmos a casa!</span>
			</div>
			
		</div>
	</div>

<div id="successBox">Salvo!</div>


	<br>&nbsp <br> &nbsp <br> &nbsp <br> &nbsp <br>
    <h1>
    Planificação Econômica Democrática com Otimização |&nbsp;<audio id="audioContainer" src="https://cast.hoost.com.br:20064/stream" autoplay controls></audio>
	</h1>
	<div id="infoBar" class="info-bar">
		<!-- Linha com GIF e informações de localização, data e hora -->
		<div class="info-row">
			<img src="https://s11.gifyu.com/images/SyrSF.gif" alt="Foice e Martelo" class="info-gif">
			<span id="infoText"></span>
		</div>
		<!-- Letreiro com imagem -->
    <div id="newsTicker" class="news-ticker">
        <marquee id="newsMarquee" style="font-size: 16px; color: white;"></marquee>
		<img src="https://images.emojiterra.com/twitter/v13.1/512px/1f4c8.png" alt="Ícone de gráfico" class="ticker-icon">
    </div>
	</div>




<div id="loginSection" class="config-section" style="display: none;">
    <h2>Login</h2>
    <!-- Campo Nome de Usuário -->
    <label for="username">Nome de Usuário: </label>
    <input type="text" id="username" name="username" placeholder="Digite seu nome de usuário" maxlength="55" style="width: 250px;">
    <br><br>

    <!-- Campo Senha -->
    <label for="password">Senha: </label>
    <input type="password" id="password" name="password" placeholder="Digite sua senha">
    <br><br>

    <!-- Botões Entrar e Cadastre-se -->
    <button id="loginButton" onclick="handleLogin()">Entrar</button>
    <button id="registerButton" onclick="showRegistrationFields()">Cadastre-se</button>
    <br><br>

    <!-- Campo Instância -->
    <div id="registrationFields" style="display: none;">
        <label for="instance">Instância: </label>
        <select id="instance" name="instance" onchange="showFields()">
            <option value="" disabled selected>Selecione...</option>
            <option value="Associação de Moradores">Associação de Moradores</option>
            <option value="Comitê de Bairro">Comitê de Bairro</option>
            <option value="Comitê de Fábrica">Comitê de Fábrica</option>
            <option value="Comitê do Campo">Comitê do Campo</option>
            <option value="Conselho Popular Distrital de Fábrica">Conselho Popular Distrital de Fábrica</option>
            <option value="Conselho Popular Distrital Urbano">Conselho Popular Distrital Urbano</option>
            <option value="Conselho Popular Municipal">Conselho Popular Municipal</option>
            <option value="Conselho Popular Regional Estadual">Conselho Popular Regional Estadual</option>
            <option value="Conselho Popular Estadual">Conselho Popular Estadual</option>
            <option value="Conselho Popular Regional Nacional">Conselho Popular Regional Nacional</option>
            <option value="Conselho Popular Regional Continental">Conselho Popular Regional Continental</option>
            <option value="Conselho Popular Continental">Conselho Popular Continental</option>
            <option value="Conselho Popular Intercontinental">Conselho Popular Intercontinental</option>
        </select>
        <br><br>

        <!-- Campos adicionais -->
		
		<div style="display: flex; align-items: center;">
			<label for="pronoun" style="margin-right: 10px;">Pronome: </label>
			<select id="pronoun" name="pronoun">
				<option value="feminino">Feminino</option>
				<option value="masculino">Masculino</option>
				<option value="neutro">Neutro</option>
			</select>
		</div>
		
        <div id="additionalFields" style="display: flex; flex-direction: column; gap: 10px;">
            <div style="display: flex; align-items: center;">
                <label for="jurisdiction" style="margin-right: 10px;">Jurisdição: </label>
                <input 
                    type="text" 
                    id="jurisdiction" 
                    name="jurisdiction" 
                    placeholder="Nome do Local, Região etc."
                    style="
                        color: gray; 
                        font-style: italic; 
                        width: 200px; 
                        background-color: transparent; 
                        border: 1px solid white;
                        padding: 5px;
                    "
                    onfocus="this.style.color='white'; this.style.fontStyle='normal'; if(this.value==='Nome do Local, Região etc.')this.value='';" 
                    onblur="if(this.value===''){this.style.color='gray'; this.style.fontStyle='italic'; this.value='Nome do Local, Região etc.';}"
                >
            </div>
            <div style="display: flex; align-items: center;">
                <label for="preposition" style="margin-right: 10px;">Preposição: </label>
                <select id="preposition" name="preposition" style="width: 80px;">
                    <option value="de">de</option>
                    <option value="da">da</option>
                    <option value="do">do</option>
                </select>
				<br><br>
				
				<!-- Botão Cadastrar -->
				<button id="registerSubmitButton" onclick="handleRegister()">Cadastrar</button>
            </div>
        </div>
    </div>	
</div>

<br>


	</div>

<div id="globeContainer"></div>

<div id="logado" style="display: none;">

    <div class="config-section">
        <h2>Tamanho da Economia</h2>
        <label for="numRows">Número de produtos:</label>
        <input type="number" id="numRows" value="3" min="1" onkeydown="handleEnter(event)">
        <label for="numCols">Número de Setores Produtivos:</label>
        <input type="number" id="numCols" value="3" min="1" onkeydown="handleEnter(event)">
		
        <button onclick="resizeTable()">Redimensionar</button>
        <button onclick="confirmClearTable()">Limpar Tabela</button>
		<button onclick="resetEconomy()">Resetar Economia</button>

        <label><input type="checkbox" id="autoFillCheckbox" onchange="toggleAutoFill()"> Preenchimento Automático</label>
    </div>

    <div class="input-section">
        <h2>Matriz Tecnológica</h2>
		<table id="inputTable">
			<thead>
				<tr>
					<th>Produtos / Setores Produtivos</th>
					<th><input type="text" value="Produzir Automóveis" ></th>
					<th><input type="text" value="Produzir Computadores" ></th>
					<th><input type="text" value="Produzir Celulares" ></th>
				</tr>
			</thead>
			<tbody id="inputTableBody">
				<!-- Linhas serão preenchidas dinamicamente -->
			</tbody>
		</table>


        <h2 id="SecaoDemandaFinal">Demanda Final</h2>
<table id="finalDemandTable">
    <thead>
        <tr>
            <th>Produto</th>
            <th>Demanda</th>
            <th>Ações</th>
        </tr>
    </thead>
    <tbody id="finalDemandInputs">
        <tr>
            <td>Automóveis</td>
            <td><input id="demand0" type="number" value="1"></td>
            <td><button onclick="openOptimizationModal(0)">Otimizar</button></td>
        </tr>
        <tr>
            <td>Computadores</td>
            <td><input id="demand1" type="number" value="0"></td>
            <td><button onclick="openOptimizationModal(1)">Otimizar</button></td>
        </tr>
        <tr>
            <td>Celulares</td>
            <td><input id="demand2" type="number" value="0"></td>
            <td><button onclick="openOptimizationModal(2)">Otimizar</button></td>
        </tr>
    </tbody>
</table>

<button onclick="planify()">Planificar</button>


    <!-- Modal para entrada de parâmetros de otimização -->
	<div id="optimizationModal" class="modal">
		<div class="modal-content">
			<div class="modal-title-bar">
				<img src="https://i.postimg.cc/TPhm79zs/pngwing-com-8.png" alt="Ícone de estrela">
				<span>Parâmetros de Otimização</span>
				&nbsp;<img src="https://i.postimg.cc/TPhm79zs/pngwing-com-8.png" alt="Ícone de estrela">
				<button class="close" onclick="closeOptimizationModal()">&times;</button>
			</div>
			<p><strong>Produto:</strong> <span id="productName"></span></p>
			<label for="workerLimit">Limite de Trabalhadores nas Fábricas:</label>
			<input type="number" id="workerLimit" required><br><br>
			<label for="workerHours">Carga Horária Diária (h):</label>
			<input type="number" id="workerHours" max="12" required><br><br>
			<label for="productionTime">Tempo para Produzir 1 Unidade (h):</label>
			<input type="number" id="productionTime" required><br><br>
			<label for="weeklyScale">Escala semanal (dias):</label>
			<input type="number" id="weeklyScale" min="1" max="7" required><br><br>
			<label for="nightShift">Turno Noturno:</label>
			<input type="checkbox" id="nightShift"><br><br>
			<button onclick="saveOptimizationInputs()">Salvar</button>
		</div>
	</div>



    <!-- Modal para exibir resultados de otimização -->
    <div id="optimizationResultModal" class="modal">
		<div class="modal-content">
			<div class="modal-title-bar">
				<img src="https://i.postimg.cc/TPhm79zs/pngwing-com-8.png" alt="Ícone de estrela">
				<span>Plano de Produção</span>
				&nbsp;<img src="https://i.postimg.cc/TPhm79zs/pngwing-com-8.png" alt="Ícone de estrela">
				<button class="close" onclick="closeOptimizationResultModal()">&times;</button>
			</div>
			<div id="optimizationResult"></div>
		</div>
	</div>


    <div class="output-section">
        <!-- Título "Planificação Otimizada", visível após clicar em "Planificar" -->
		<h2 id="planificationTitle" style="display: none;">Planificação Otimizada</h2>
        <div id="result"></div>
    </div>

<!-- Botão "Dados copiáveis", visível após clicar em "Planificar" -->
<button id="openCopyableDataModal" class="btn" style="display: none;">Dados copiáveis</button>

<!-- Janela modal para exibir os dados copiáveis -->
<div id="copyableDataModal" class="modal" style="display: none;">
    <div class="modal-content">
        <div class="modal-title-bar">
			<img src="https://i.postimg.cc/TPhm79zs/pngwing-com-8.png" alt="Ícone de estrela">
			<span>Dados Copiáveis</span>
			&nbsp;<img src="https://i.postimg.cc/TPhm79zs/pngwing-com-8.png" alt="Ícone de estrela">
			<button class="close" onclick="closeCopyableDataModal()">&times;</button>
		</div>

        <div class="modal-body">
            <h3>Matriz de Entrada (para cópia)</h3>
            <pre id="matrixModalOutput" style="background-color: #333; color: white; padding: 10px; border-radius: 8px; overflow-x: auto;"></pre>
            <h3>Vetor de Demanda (para cópia)</h3>
            <pre id="vectorModalOutput" style="background-color: #333; color: white; padding: 10px; border-radius: 8px; overflow-x: auto;"></pre>
        </div>
    </div>
</div>

<button id="downloadDataButton" class="btn" style="display: none;">Baixar Dados</button>
<button id="uploadDataButton" class="btn">Upload de Dados</button>
<input type="file" id="uploadInput" style="display: none;" accept=".csv" />
<button id="sendDataButton" class="btn" onclick="sendDataToJsonBin()" style="display: none;">Enviar Dados</button>
<button id="fetchDataButton" class="btn" onclick="fetchDataFromJsonBin()">Receber Dados</button>

</div>

    <script>
	
		let userIsLoggedIn = false;
		let user = null;
		let primeiroConselheiroDoConselho = true;
		// Variáveis globais para armazenar os dados antigos
		let previousTableData = [];
		let previousProductNames = [];
		let previousSectorNames = [];
		let previousDemandValues = [];
	
		const productNames = [
            "Automóveis", "Computadores", "Celulares", "Geladeiras", "Televisores",
            "Roupas de algodão", "Embalagens plásticas", "Móveis de madeira", "Aço",
            "Vidro", "Produtos de limpeza", "Tintas", "Cosméticos", "Borracha",
            "Medicamentos", "Papel", "Embalagens de alumínio", "Fertilizantes",
            "Peças automotivas", "Componentes eletrônicos"
        ];

        const inputNames = [
            "Aço", "Plástico", "Alumínio", "Madeira", "Vidro", "Algodão", "Borracha",
            "Produtos químicos", "Cobre", "Tinta", "Polímeros", "Petróleo", "Sílica",
            "Borracha sintética", "Lítio", "Carbonato de cálcio", "Petróleo refinado",
            "Bioetanol", "Minério de ferro", "Celulose"
        ];

        const predefinedValues = [
            [0.2, 0.1, 0.05, 0.02, 0.05, 0.1, 0.02, 0.1, 0.08, 0.1, 0.02, 0.05, 0.02, 0.08, 0.05, 0.04, 0.02, 0.02, 0.05, 0.05],
            [0.05, 0.2, 0.08, 0.1, 0.03, 0.05, 0.1, 0.02, 0.07, 0.05, 0.1, 0.03, 0.05, 0.08, 0.1, 0.02, 0.04, 0.02, 0.07, 0.04],
            [0.03, 0.1, 0.2, 0.02, 0.08, 0.07, 0.02, 0.05, 0.1, 0.05, 0.04, 0.02, 0.07, 0.1, 0.02, 0.08, 0.05, 0.05, 0.02, 0.08],
            [0.08, 0.05, 0.02, 0.2, 0.05, 0.1, 0.05, 0.07, 0.02, 0.1, 0.08, 0.03, 0.02, 0.05, 0.04, 0.1, 0.05, 0.1, 0.02, 0.07],
            [0.1, 0.02, 0.05, 0.03, 0.2, 0.05, 0.1, 0.02, 0.07, 0.05, 0.1, 0.04, 0.05, 0.03, 0.1, 0.08, 0.05, 0.1, 0.07, 0.02],
            [0.05, 0.1, 0.02, 0.08, 0.03, 0.2, 0.07, 0.05, 0.1, 0.04, 0.05, 0.1, 0.02, 0.1, 0.05, 0.08, 0.05, 0.03, 0.1, 0.04],
            [0.07, 0.02, 0.05, 0.1, 0.05, 0.1, 0.2, 0.03, 0.02, 0.07, 0.08, 0.05, 0.1, 0.02, 0.05, 0.07, 0.1, 0.04, 0.08, 0.05],
            [0.02, 0.05, 0.1, 0.05, 0.07, 0.03, 0.1, 0.2, 0.08, 0.05, 0.03, 0.08, 0.02, 0.1, 0.05, 0.1, 0.07, 0.05, 0.02, 0.04],
            [0.05, 0.1, 0.02, 0.1, 0.04, 0.05, 0.07, 0.05, 0.2, 0.08, 0.1, 0.02, 0.05, 0.1, 0.05, 0.04, 0.08, 0.07, 0.02, 0.1],
            [0.1, 0.05, 0.07, 0.05, 0.08, 0.1, 0.03, 0.1, 0.05, 0.2, 0.05, 0.07, 0.04, 0.1, 0.03, 0.05, 0.1, 0.04, 0.07, 0.08],
            [0.02, 0.07, 0.05, 0.04, 0.1, 0.08, 0.05, 0.1, 0.1, 0.03, 0.2, 0.02, 0.07, 0.05, 0.1, 0.04, 0.08, 0.05, 0.1, 0.02],
            [0.05, 0.1, 0.08, 0.02, 0.04, 0.05, 0.1, 0.03, 0.1, 0.07, 0.02, 0.2, 0.08, 0.05, 0.04, 0.05, 0.1, 0.1, 0.03, 0.07],
            [0.03, 0.05, 0.1, 0.08, 0.1, 0.02, 0.07, 0.05, 0.05, 0.04, 0.1, 0.07, 0.2, 0.02, 0.05, 0.05, 0.08, 0.1, 0.04, 0.05],
            [0.1, 0.05, 0.03, 0.07, 0.05, 0.1, 0.02, 0.05, 0.1, 0.05, 0.1, 0.08, 0.04, 0.2, 0.07, 0.02, 0.05, 0.05, 0.1, 0.03],
            [0.05, 0.1, 0.02, 0.05, 0.08, 0.1, 0.07, 0.1, 0.03, 0.1, 0.05, 0.04, 0.05, 0.08, 0.2, 0.05, 0.1, 0.03, 0.07, 0.02],
            [0.04, 0.05, 0.1, 0.05, 0.02, 0.07, 0.08, 0.1, 0.05, 0.04, 0.08, 0.1, 0.03, 0.05, 0.07, 0.2, 0.1, 0.02, 0.05, 0.05],
            [0.05, 0.08, 0.02, 0.1, 0.07, 0.04, 0.05, 0.03, 0.05, 0.07, 0.1, 0.1, 0.02, 0.1, 0.04, 0.05, 0.2, 0.1, 0.07, 0.03],
            [0.03, 0.07, 0.05, 0.05, 0.1, 0.02, 0.1, 0.04, 0.08, 0.1, 0.05, 0.1, 0.02, 0.07, 0.05, 0.08, 0.03, 0.2, 0.05, 0.1],
            [0.07, 0.05, 0.04, 0.1, 0.05, 0.02, 0.08, 0.05, 0.1, 0.1, 0.03, 0.05, 0.05, 0.04, 0.1, 0.07, 0.02, 0.05, 0.2, 0.08],
            [0.05, 0.03, 0.1, 0.04, 0.07, 0.05, 0.08, 0.1, 0.02, 0.05, 0.1, 0.05, 0.07, 0.08, 0.02, 0.1, 0.03, 0.07, 0.08, 0.2]
        ];
	
        let currentProductIndex = null;
        let optimizationInputs = {};  // Objeto para armazenar os dados de entrada de otimização de cada produto
        let optimizationResults = {};

		let optimizedStatus = {};  // Objeto para armazenar o status de otimização de cada produto


// Função para preencher a tabela com valores iniciais baseados em predefinedValues
function populateInitialTable() {
    const tbody = document.getElementById('inputTableBody');
    tbody.innerHTML = ''; // Limpa qualquer conteúdo existente na tabela

    const initialRows = 3;
    const initialCols = 3;

    // Atualiza o cabeçalho da tabela
    const thead = document.getElementById('inputTable').querySelector('thead tr');
    thead.innerHTML = '<th>Produtos / Setores Produtivos</th>';
    for (let colIndex = 0; colIndex < initialCols; colIndex++) {
        const sectorHeader = document.createElement('th');
        const sectorInput = document.createElement('input');
        sectorInput.type = 'text';
        sectorInput.value = `Produzir ${colIndex < initialRows ? productNames[colIndex] : "Outro"}`; 
        //sectorInput.oninput = () => updateProductName(colIndex, sectorInput.value);
        sectorInput.readOnly = true; // Define como apenas leitura
        sectorHeader.appendChild(sectorInput);
        thead.appendChild(sectorHeader);
    }

    // Atualiza as linhas da tabela
    for (let rowIndex = 0; rowIndex < initialRows; rowIndex++) {
        const row = document.createElement('tr');

        // Adicionar o campo de entrada para o nome do produto
        const productNameCell = document.createElement('td');
        const productInput = document.createElement('input');
        productInput.type = 'text';
        productInput.value = productNames[rowIndex];
        productInput.oninput = (e) => updateProductName(rowIndex, e.target.value);
        productNameCell.appendChild(productInput);
        row.appendChild(productNameCell);

        // Adicionar as células restantes
        for (let colIndex = 0; colIndex < initialCols; colIndex++) {
            const cell = document.createElement('td');
            const input = document.createElement('input');
            input.type = 'number';
            input.value = predefinedValues[rowIndex][colIndex];
            cell.appendChild(input);
            row.appendChild(cell);
        }

        tbody.appendChild(row);
    }
}



// Chama a função populateInitialTable() ao carregar a página
window.onload = function() {
    populateInitialTable(); // Carrega a tabela inicial
    document.getElementById('welcomeModal').style.display = 'flex'; // Exibe o modal de boas-vindas
	togglePlanificationElements();  // Garante que os elementos estejam ocultos no carregamento
	
	try {
        document.getElementById('fetchDataButton').click();
    } catch (error) {
        console.error("Erro ao executar 'Receber Dados':", error);
    }
	
	showNotification("Olá! Se for Conselheiro você pode fazer login.", true);
	
	initSmallGlobe();
	
}

// Função para fechar o modal
function closeWelcomeModal() {
    const modal = document.getElementById('welcomeModal');
    modal.style.display = 'none';
}


		document.addEventListener('keydown', (event) => {
			if (event.key === 'Escape') {
				const welcomeModal = document.getElementById('welcomeModal');
				const optimizationModal = document.getElementById('optimizationModal');
				const optimizationResultModal = document.getElementById('optimizationResultModal');
				const copyableDataModal = document.getElementById('copyableDataModal');

				// Fecha o modal de boas-vindas ao pressionar "Esc"
				if (welcomeModal && welcomeModal.style.display === 'flex') {
					closeWelcomeModal();
				}

				// Fecha o modal de parâmetros de otimização ao pressionar "Esc"
				if (optimizationModal && optimizationModal.style.display === 'flex') {
					closeOptimizationModal();
				}

				// Fecha o modal de resultados de otimização ao pressionar "Esc"
				if (optimizationResultModal && optimizationResultModal.style.display === 'flex') {
					closeOptimizationResultModal();
				}
				
				// Fecha o modal de "Dados Copiáveis" se estiver aberto
				if (copyableDataModal.style.display === 'flex') {
					copyableDataModal.style.display = 'none'; // Fecha o modal de dados copiáveis
				}
				
			}
			
			if (event.ctrlKey && event.key === 'Enter') {
				event.preventDefault(); // Impede ações padrão, se houver
				planify(); // Chama a função de planificação
			}
			
			 if (event.ctrlKey) {
				// Filtra apenas as combinações específicas configuradas no programa
				if (event.key === 'd' || event.key === 'D') {
					event.preventDefault(); // Impede a ação padrão apenas para CTRL+S
					const downloadButton = document.getElementById('downloadDataButton');
					if (downloadButton) {
						downloadButton.click();
					}
				} else if (event.key === 'o' || event.key === 'O') {
					event.preventDefault(); // Impede a ação padrão apenas para CTRL+O
					const uploadButton = document.getElementById('uploadDataButton');
					if (uploadButton) {
						uploadButton.click();
					}
				} else if (event.key === 's' || event.key === 'S') {
					event.preventDefault(); // Impede o comportamento padrão do navegador (salvar página)
					
					if (userIsLoggedIn) { // Verifica se o usuário está logado
						const sendButton = document.getElementById('sendDataButton');
						if (sendButton) {
							sendButton.click(); // Simula o clique no botão "Enviar Dados"
						}
					} else {
						showNotification("Você precisa estar logado para poder salvar suas alterações", false);
					}
				} else if (event.key === 'Backspace') {
					event.preventDefault(); // Evita a ação padrão do navegador
					confirmClearTable(); // Chama a função de confirmação antes de limpar
				} else if (event.ctrlKey && (event.key === 'e' || event.key === 'E')) {
					if (userIsLoggedIn) { // Verifica se o usuário está logado
						event.preventDefault(); // Impede o comportamento padrão
						logout(); // Simula o clique no botão "Sair"
					}
					// Se o usuário não estiver logado, o comportamento padrão é mantido
				} else if (event.ctrlKey && (event.key === 'l' || event.key === 'L')) {
					event.preventDefault(); // Previne o comportamento padrão
					if (!userIsLoggedIn) { // Verifica se o usuário não está logado
						showLoginSection();
					}
				}
	
			}
		});

function saveOptimizationInputs() {
    const workerLimit = parseFloat(document.getElementById('workerLimit').value);
    const workerHours = parseFloat(document.getElementById('workerHours').value);
    const productionTime = parseFloat(document.getElementById('productionTime').value);
    const nightShift = document.getElementById('nightShift').checked;
    const weeklyScale = parseInt(document.getElementById('weeklyScale').value);

    // Verificação dos campos obrigatórios
    if (
        isNaN(workerLimit) ||
        isNaN(workerHours) ||
        isNaN(productionTime) ||
        isNaN(weeklyScale) ||
        weeklyScale < 1 ||
        weeklyScale > 7
    ) {
        showNotification("Por favor, preencha todos os campos corretamente. A escala semanal deve estar entre 1 e 7 dias.", false);
        return;
    }

    // Limitar a carga horária diária a no máximo 12 horas
    if (workerHours > 12) {
        showNotification("A carga horária diária não pode ser maior do que 12 horas.", false);
        return;
    }

    // Salva os dados no objeto de otimização
    if (!optimizationInputs[currentProductIndex]) {
        optimizationInputs[currentProductIndex] = {}; // Inicializa se não existir
    }

    optimizationInputs[currentProductIndex] = {
        workerLimit,
        workerHours,
        productionTime,
        nightShift,
        weeklyScale
    };

// Atualiza os botões de otimização
    updateOptimizeButtonColor(currentProductIndex);
    closeOptimizationModal();	

    optimizedStatus[currentProductIndex] = true; // Marca o produto como otimizado
    updateOptimizeButtonColor(currentProductIndex); // Atualiza a cor do botão

    closeOptimizationModal(); // Fecha o modal após salvar

    // Verifica se a tabela de "Planificação Otimizada" está visível e executa a função "planify" automaticamente
    const resultDiv = document.getElementById('result');
    if (resultDiv && resultDiv.innerHTML.trim() !== '') {
        planify();
    }
	
	
	
}


// Atualiza a função closeOptimizationModal para remover o ouvinte de eventos ao fechar o modal
function closeOptimizationModal() {
    document.getElementById('optimizationModal').style.display = 'none';
    document.removeEventListener('keydown', handleEnterPress); // Remove o ouvinte ao fechar o modal
}

// Função para redimensionar a tabela e preservar dados antigos
function resizeTable() {
    const numRows = parseInt(document.getElementById('numRows').value);
    const numCols = parseInt(document.getElementById('numCols').value);

    const table = document.getElementById('inputTable');
    const tbody = table.querySelector('tbody');
    const thead = table.querySelector('thead');

    // Armazenar os dados antigos antes do redimensionamento
    storePreviousTableData();
    storePreviousDemandValues();

    // Atualiza o cabeçalho da tabela com os nomes dos setores produtivos
    thead.innerHTML = '<tr><th>Produtos / Setor Produtivo</th></tr>';
    for (let j = 0; j < numCols; j++) {
        const sectorHeader = document.createElement('th');
        const sectorInput = document.createElement('input');
        sectorInput.type = 'text';
        sectorInput.value = previousSectorNames[j] || `Produzir ${inputNames[j % inputNames.length]}`;
        sectorHeader.appendChild(sectorInput);
        thead.querySelector('tr').appendChild(sectorHeader);
    }

    // Redimensiona o corpo da tabela preservando os dados antigos
    tbody.innerHTML = '';
    for (let i = 0; i < numRows; i++) {
        const row = document.createElement('tr');

        // Nome do produto
        const productNameCell = document.createElement('td');
        const productInput = document.createElement('input');
        productInput.type = 'text';
        productInput.value = previousProductNames[i] || `Produto ${i + 1}`;
        productInput.onchange = () => syncProductName(i, productInput.value);  // Sincroniza nome de produto
        productNameCell.appendChild(productInput);
        row.appendChild(productNameCell);

        for (let j = 0; j < numCols; j++) {
            const cell = document.createElement('td');
            const input = document.createElement('input');
            input.type = 'number';

            // Preenche com o valor antigo ou usa um valor padrão
            input.value = (previousTableData[i] && previousTableData[i][j] !== undefined)
                ? previousTableData[i][j]
                : predefinedValues[i % predefinedValues.length][j % predefinedValues[0].length];

            input.onchange = storePreviousTableData;
            cell.appendChild(input);
            row.appendChild(cell);
        }

        tbody.appendChild(row);
    }

    // Atualiza a seção de demanda final com os nomes dos produtos e valores de demanda preservados
    updateFinalDemand(numRows);

    // Se preenchimento automático estiver habilitado, preenche automaticamente novos campos
    if (document.getElementById('autoFillCheckbox').checked) {
        autoFillTable();
    }

    // Atualiza os dados antigos
    storePreviousTableData();
}



// Função para armazenar os dados antigos da tabela, incluindo nomes dos produtos e setores
function storePreviousTableData() {
    const tbody = document.getElementById('inputTable').querySelector('tbody');
    const thead = document.getElementById('inputTable').querySelector('thead');

    previousTableData = [];
    previousProductNames = [];
    previousSectorNames = [];
    previousDemandValues = []; // Armazenar os valores de demanda

    // Armazena os nomes dos setores
    const sectorHeaders = thead.querySelectorAll('th input');
    sectorHeaders.forEach((input, index) => {
        if (index > 0) previousSectorNames[index - 1] = input.value;
    });

    // Armazena os dados da tabela e os nomes dos produtos
    tbody.querySelectorAll('tr').forEach((row, index) => {
        const rowData = [];
        const productInput = row.querySelector('td:first-child input');
        previousProductNames[index] = productInput.value;

        row.querySelectorAll('td:not(:first-child) input').forEach((input) => {
            rowData.push(input.value || 0);
        });
        previousTableData.push(rowData);
    });

    // Armazena os valores de demanda atuais
    const demandInputs = document.querySelectorAll('#finalDemandInputs input[type="number"]');
    demandInputs.forEach(input => previousDemandValues.push(input.value || 0));
}

// Função para armazenar os valores antigos da demanda final
function storePreviousDemandValues() {
    const demandInputs = document.querySelectorAll('#finalDemandInputs input[type="number"]');
    previousDemandValues = Array.from(demandInputs).map(input => input.value || 0);
}

// Função para atualizar a tabela de demanda final
function updateFinalDemand(numRows) {
    const demandContainer = document.getElementById('finalDemandInputs');
    demandContainer.innerHTML = '';

    for (let i = 0; i < numRows; i++) {
        const demandRow = document.createElement('tr');

        // Nome do produto sincronizado com a tabela
        const productNameCell = document.createElement('td');
        productNameCell.textContent = previousProductNames[i] || `Produto ${i + 1}`;
        demandRow.appendChild(productNameCell);

        // Entrada de demanda (preserva valor existente ou padrão)
        const demandInputCell = document.createElement('td');
        const demandInput = document.createElement('input');
        demandInput.type = 'number';
        demandInput.id = `demand${i}`;
        demandInput.value = previousDemandValues[i] || (i === 0 ? 1 : 0);
        demandInputCell.appendChild(demandInput);
        demandRow.appendChild(demandInputCell);

        // Botão de otimização
        const buttonCell = document.createElement('td');
        const button = document.createElement('button');
        button.textContent = 'Otimizar';
        button.onclick = () => openOptimizationModal(i);
        buttonCell.appendChild(button);
        demandRow.appendChild(buttonCell);

        demandContainer.appendChild(demandRow);

        // Atualizar a cor do botão com base no status de otimização
        updateOptimizeButtonColor(i);
    }
}

// Função para atualizar a tabela de demanda final
function updateFinalDemand(numRows) {
    const demandContainer = document.getElementById('finalDemandInputs');
    demandContainer.innerHTML = '';

    for (let i = 0; i < numRows; i++) {
        const demandRow = document.createElement('tr');

        // Nome do produto sincronizado com a tabela
        const productNameCell = document.createElement('td');
        productNameCell.textContent = previousProductNames[i] || `Produto ${i + 1}`;
        demandRow.appendChild(productNameCell);

        // Entrada de demanda (preserva valor existente ou padrão)
        const demandInputCell = document.createElement('td');
        const demandInput = document.createElement('input');
        demandInput.type = 'number';
        demandInput.id = `demand${i}`;
        demandInput.value = previousDemandValues[i] !== undefined ? previousDemandValues[i] : (i === 0 ? 1 : 0);
        demandInputCell.appendChild(demandInput);
        demandRow.appendChild(demandInputCell);

        // Botão de otimização
        const buttonCell = document.createElement('td');
        const button = document.createElement('button');
        button.textContent = 'Otimizar';
        button.onclick = () => openOptimizationModal(i);
        buttonCell.appendChild(button);
        demandRow.appendChild(buttonCell);

        demandContainer.appendChild(demandRow);

        // Atualizar a cor do botão com base no status de otimização
        updateOptimizeButtonColor(i);
    }
}

// Função para atualizar os dados antigos da tabela
function updatePreviousTableData() {
    const tbody = document.getElementById('inputTable').querySelector('tbody');
    previousTableData = [];
    tbody.querySelectorAll('tr').forEach((row) => {
        const rowData = [];
        row.querySelectorAll('input[type="number"]').forEach((input) => {
            rowData.push(input.value || 0);
        });
        previousTableData.push(rowData);
    });
}



	function performOptimization(productIndex) {
    const inputs = optimizationInputs[productIndex];
    if (!inputs) return;

    const { productionGoal, workerLimit, workerHours, productionTime, weeklyScale, nightShift } = inputs;

	if (!workerLimit || workerLimit <= 0) {
        const productName = getProductNames()[productIndex];
        //showNotification(`O limite de trabalhadores por fábrica não foi configurado corretamente para a produção de ${productName}.`);
        return;
    }

    // Cálculo total de horas necessárias para produzir a quantidade desejada
    const totalHours = productionTime * productionGoal;

    // Capacidade semanal por trabalhador (em horas)
    const weeklyWorkHoursPerWorker = weeklyScale * workerHours;

    // Cálculo do número de trabalhadores necessários
    const workersNeeded = Math.ceil(totalHours / weeklyWorkHoursPerWorker);

    // Capacidade total de trabalho por turno (independente de ser diurno ou noturno)
    const shiftWorkHours = workerLimit * workerHours;

    // Total de turnos necessários
    const totalShifts = Math.ceil(totalHours / shiftWorkHours);

    // Capacidade diária considerando escala semanal e turno noturno
    const dailyWorkHours = nightShift ? shiftWorkHours * 2 : shiftWorkHours;
    const totalDailyWorkHours = dailyWorkHours * weeklyScale / 7;

    // Prazo mínimo de produção em dias
    const minimumProductionTime = Math.ceil(totalHours / totalDailyWorkHours);

    // Período total de trabalho (em semanas e dias restantes)
    const totalWorkDays = Math.ceil(totalHours / dailyWorkHours);
    const totalWeeks = Math.floor(totalWorkDays / weeklyScale);
    const remainingDays = totalWorkDays % weeklyScale;

	// Cálculo das horas de operação por dia
	const factoryOperationHours = nightShift ? 24 : 12;

	// Conversão do prazo mínimo de produção para dias
	const minimumProductionTimeInDays = minimumProductionTime / 24; // Considera 1 dia = 24 horas

	// Nova fórmula para calcular o número de fábricas necessárias
	const factoriesNeeded = Math.ceil(totalHours / (factoryOperationHours * workerLimit * minimumProductionTimeInDays));



	// Cálculo da quantidade de fábricas
	//const factoriesNeeded = Math.ceil(totalHours / shiftWorkHours);

    // Formatação do período total de emprego
    let totalEmploymentPeriod;
    if (totalWorkDays < weeklyScale) {
        totalEmploymentPeriod = `${totalWorkDays} dias`;
    } else {
        totalEmploymentPeriod = formatDays(totalWorkDays * 24); // Converte dias em horas para formatDays
    }

    // Armazenamento dos resultados para exibição
    optimizationResults[productIndex] = {
        totalHours,
        workersNeeded,
        factoriesNeeded, // Adiciona o cálculo das fábricas
        totalShifts,
        minimumProductionTime,
        totalEmploymentPeriod,
        weeklyScale
    };
}

let isPlanified = false; // Variável para controlar se a planificação foi feita

function planify() {
    const resultDiv = document.getElementById('result');
    resultDiv.innerHTML = "";

    try {
        const techMatrix = makeSquareMatrix(getTableData());
        const adjustedDemand = adjustDemandVector(getFinalDemand(), techMatrix.length);
        const identityMatrix = math.identity(techMatrix.length)._data;
        const iMinusA = math.subtract(identityMatrix, techMatrix);
        const inverseIMinusA = math.inv(iMinusA);
        const productionVector = math.multiply(inverseIMinusA, adjustedDemand);

        const productNames = getProductNames();
        resultDiv.innerHTML = `
            <table>
                <thead>
                    <tr>
                        <th>Produto</th>
                        <th>Produção Necessária para Atender a Demanda Final</th>
                        <th>Ações</th>
                    </tr>
                </thead>
                <tbody>
                    ${productionVector.map((val, i) => {
                        const hasOptimization = isOptimizationDataComplete(i); // Validação aqui
                        return `
                            <tr>
                                <td>${productNames[i]}</td>
                                <td>${val.toFixed(2)}</td>
                                <td>
                                    ${hasOptimization ? 
                                    `<button onclick="openOptimizationResultModal(${i})">Otimização</button>` : 
                                    `<button disabled>Otimização Não Disponível</button>`}
                                </td>
                            </tr>
                        `;
                    }).join('')}
                </tbody>
            </table>
        `;

        // Define a meta de produção e executa a otimização para cada produto com dados completos
        productionVector.forEach((value, index) => {
            if (isOptimizationDataComplete(index)) {
                optimizationInputs[index].productionGoal = value * 1000; // Define a meta
                performOptimization(index); // Executa a otimização
                updateOptimizeButtonColor(index); // Atualiza o botão após a otimização
            }
        });

        // Formatação da matriz e vetor para exibição
        const formattedMatrix = JSON.stringify(techMatrix, null, 2);
        const formattedVector = JSON.stringify(adjustedDemand, null, 2);

        // Preenche os elementos na modal
        document.getElementById('matrixModalOutput').textContent = formattedMatrix;
        document.getElementById('vectorModalOutput').textContent = formattedVector;

        // Marca que a planificação foi feita e exibe o título e o botão
        isPlanified = true;
        togglePlanificationElements();

		// Rolagem suave para o título "Planificação Otimizada"
		const planificationTitle = document.getElementById('planificationTitle'); // Seleciona o título "Planificação Otimizada"
		const infobar = document.getElementById('infoBar'); // Seleciona a infobar

		if (planificationTitle) {
			const infobarHeight = infobar ? infobar.offsetHeight : 0; // Calcula a altura da infobar
			const planificationTitlePosition = planificationTitle.getBoundingClientRect().top + window.scrollY; // Posição do título na página
			const targetPosition = planificationTitlePosition - infobarHeight; // Compensa a altura da infobar

			// Rola suavemente para a posição ajustada
			window.scrollTo({
				top: targetPosition,
				behavior: 'smooth',
			});
		}


    } catch (error) {
        resultDiv.innerHTML = `<p class="error-message">Erro: ${error.message}</p>`;
    }
}


function togglePlanificationElements() {
    const planificationTitle = document.getElementById('planificationTitle');
    const copyableButton = document.getElementById('openCopyableDataModal');
    const downloadButton = document.getElementById('downloadDataButton');

    if (isPlanified) {
        planificationTitle.style.display = 'block';  // Exibe o título
        copyableButton.style.display = 'block';      // Exibe o botão "Dados copiáveis"
        downloadButton.style.display = 'block';      // Exibe o botão "Baixar Dados"
    } else {
        planificationTitle.style.display = 'none';   // Oculta o título
        copyableButton.style.display = 'none';       // Oculta o botão "Dados copiáveis"
        downloadButton.style.display = 'none';       // Oculta o botão "Baixar Dados"
    }
}


// Função para fechar modais ao clicar fora do conteúdo
// Fecha os modais ao clicar fora do conteúdo
window.addEventListener('click', (event) => {
    const welcomeModal = document.getElementById('welcomeModal');
    const optimizationModal = document.getElementById('optimizationModal');
    const optimizationResultModal = document.getElementById('optimizationResultModal');
	const copyableDataModal = document.getElementById('copyableDataModal');


    // Fecha o modal de boas-vindas ao clicar fora dele
    if (event.target === welcomeModal) {
        closeWelcomeModal();
    }

    // Fecha o modal de parâmetros de otimização ao clicar fora dele
    if (event.target === optimizationModal) {
        closeOptimizationModal();
    }

    // Fecha o modal de resultados de otimização ao clicar fora dele
    if (event.target === optimizationResultModal) {
        closeOptimizationResultModal();
    }
	
	// Fecha a modal de "Dados Copiáveis"
    if (
        copyableDataModal &&
        copyableDataModal.style.display === 'flex' &&
        !copyableDataModal.querySelector('.modal-content').contains(event.target) &&
        event.target.id !== 'openCopyableDataModal' // Garante que o botão de abrir não feche a modal
    ) {
        closeCopyableDataModal();
    }
	
});

function closeCopyableDataModal() {
    const modal = document.getElementById('copyableDataModal');
    modal.style.display = 'none'; // Fecha a modal
}

// Função para fechar a modal de otimização
function closeOptimizationModal() {
    document.getElementById('optimizationModal').style.display = 'none';
}

// Exibe os resultados da otimização no modal de resultados
	function openOptimizationResultModal(index) {
    const result = optimizationResults[index];
    const inputs = optimizationInputs[index];
    if (!result || !inputs) return;

    const productName = getProductNames()[index];
    const workerHours = inputs.workerHours; // Carga horária diária configurada
    const totalHours = result.totalHours; // Total de horas de trabalho
    const workersNeeded = result.workersNeeded; // Trabalhadores necessários
    const totalShifts = result.totalShifts; // Total de turnos de trabalho
    const minimumProductionTime = result.minimumProductionTime; // Prazo mínimo de produção
    const totalEmploymentPeriod = result.totalEmploymentPeriod; // Período total em que estarão empregados
    const weeklyScale = result.weeklyScale; // Escala semanal
    const workShift = inputs.nightShift ? "Diurno e Noturno" : "Diurno"; // Verifica o tipo de turno
	const factoriesNeeded = result.factoriesNeeded;

    const daysOff = 7 - weeklyScale; // Dias de folga na semana
    const formattedWeeklyScale = `${weeklyScale}X${daysOff}`; // Formata como solicitado

    document.getElementById('optimizationResult').innerHTML = `
		<p><strong>Produto:</strong> ${productName}</p>
		<p><strong>Carga Horária Total:</strong> ${totalHours.toFixed(2)} horas</p>
		<p><strong>Fábricas Necessárias:</strong> ${factoriesNeeded}</p>
		<p><strong>Prazo Mínimo de Produção:</strong> ${formatDays(minimumProductionTime * 24)}</p>
		<p><strong>Turno:</strong> ${workShift}</p>
		<p><strong>Trabalhadores Necessários:</strong> ${workersNeeded}</p>
		<p><strong>Total de Turnos:</strong> ${totalShifts}</p>
		<p><strong>Expediente do Trabalhador:</strong> ${workerHours}h por dia</p>
		<p><strong>Escala de Trabalho:</strong> ${formattedWeeklyScale}</p>
		<p><strong>Período Total de Emprego:</strong> ${totalEmploymentPeriod}</p>
	`;


    const modal = document.getElementById('optimizationResultModal');
    modal.style.display = 'flex';
}

// Função para fechar a modal de resultados de otimização
function closeOptimizationResultModal() {
    document.getElementById('optimizationResultModal').style.display = 'none';
}

        function closeOptimizationModal() {
            document.getElementById('optimizationModal').style.display = 'none';
        }

        

		function updateOptimizeButtonColor(productIndex) {
			const button = document.querySelector(`#finalDemandInputs tr:nth-child(${productIndex + 1}) button`);
			const inputs = optimizationInputs[productIndex];

			// Verifica se todos os campos obrigatórios estão preenchidos
			const isComplete = inputs && 
				inputs.workerLimit > 0 && 
				inputs.workerHours > 0 &&
				inputs.productionTime > 0 &&
				inputs.weeklyScale > 0;

			if (isComplete) {
				button.style.backgroundColor = 'green'; // Dados completos, botão fica verde
			} else {
				button.style.backgroundColor = '';     // Reseta a cor do botão
			}
		}



       function openOptimizationModal(productIndex) {
    currentProductIndex = productIndex;

    // Inicializa os dados de otimização para o produto, se necessário
    if (!optimizationInputs[productIndex]) {
        optimizationInputs[productIndex] = {};
    }
    const inputs = optimizationInputs[productIndex] || {}; // Obtém ou inicializa os dados

    // Define o nome do produto no modal
    const productNames = getProductNames();
    document.getElementById('productName').textContent = productNames[productIndex];

    // Preenche os campos do modal com valores salvos ou padrão
    document.getElementById('workerLimit').value = inputs.workerLimit || '';
    document.getElementById('workerHours').value = inputs.workerHours || '';
    document.getElementById('productionTime').value = inputs.productionTime || '';
    document.getElementById('nightShift').checked = inputs.nightShift || false;
	document.getElementById('weeklyScale').value = inputs.weeklyScale || '';

    // Exibe o modal de otimização
    const modal = document.getElementById('optimizationModal');
    modal.style.display = 'flex';

    // Posiciona o cursor automaticamente no campo "Limite de Trabalhadores nas Fábricas"
    document.getElementById('workerLimit').focus();

    // Adiciona o ouvinte de eventos para capturar Enter
    document.addEventListener('keydown', handleEnterPress);
}






// Função para acionar "Salvar" ao pressionar Enter
function handleEnterPress(event) {
    if (event.key === 'Enter') {
        event.preventDefault(); // Impede o comportamento padrão do Enter
        saveOptimizationInputs();
        document.removeEventListener('keydown', handleEnterPress); // Remove o ouvinte após salvar
    }
}


function handleEnter(event) {
    if (event.key === "Enter") {
        event.preventDefault(); // Impede o comportamento padrão do Enter
        resizeTable(); // Chama a função para redimensionar a tabela
    }
}


        function closeOptimizationModal() {
			const modal = document.getElementById('optimizationModal');
			modal.style.display = 'none';
			document.removeEventListener('keydown', handleEnterPress); // Remove o ouvinte ao fechar
		}



        function toggleAutoFill() {
            if (document.getElementById('autoFillCheckbox').checked) {
                autoFillTable();
            } else {
                clearTable();
            }
        }

        function autoFillTable() {
            const rows = document.getElementById('inputTable').querySelectorAll('tbody tr');
            const productNames = ["Automóveis", "Computadores", "Celulares", "Geladeiras", "Televisores"];

            rows.forEach((row, i) => {
                row.cells[0].querySelector('input[type="text"]').value = productNames[i % productNames.length];
                let rowValues = [];
                let sum = 0;

                for (let j = 1; j < row.cells.length; j++) {
                    let value = i === j ? (Math.random() * 0.05).toFixed(2) : (Math.random() * 0.1).toFixed(2);
                    rowValues.push(parseFloat(value));
                    sum += parseFloat(value);
                }

                if (sum >= 1) {
                    rowValues = rowValues.map(value => (value / sum * 0.9).toFixed(2));
                }

                rowValues.forEach((value, j) => {
                    row.cells[j + 1].querySelector('input[type="number"]').value = value;
                });
            });
        }

        function getTableData() {
			const tbody = document.querySelector('#inputTable tbody');
			const rows = tbody.querySelectorAll('tr');

			return Array.from(rows).map(row => {
				const cells = row.querySelectorAll('td:not(:first-child) input[type="number"]');
				return Array.from(cells).map(input => parseFloat(input.value) || 0);
			});
		}
        

		function getProductNames() {
			const rows = document.querySelectorAll('#inputTable tbody tr');
			return Array.from(rows).map(row => row.querySelector('td:first-child input').value);
		}

		function setProductNames(productNames) {
			const rows = document.querySelectorAll('#inputTable tbody tr');
			rows.forEach((row, index) => {
				const input = row.querySelector('td:first-child input');
				if (input && productNames[index]) {
					input.value = productNames[index];
				}
			});
		}

		function setSectorNames(sectorNames) {
			const headers = document.querySelectorAll('#inputTable thead tr th');
			headers.forEach((header, index) => {
				if (index > 0 && sectorNames[index - 1]) { // Pula a primeira coluna ("Produtos")
					const input = header.querySelector('input');
					if (input) {
						input.value = sectorNames[index - 1]; // Define o título correto do setor
					}
				}
			});
		}
		
		function getSectorNames() {
			const headers = document.querySelectorAll('#inputTable thead tr th');
			return Array.from(headers)
				.slice(1) // Ignora a primeira coluna (nomes dos produtos)
				.map(header => {
					const input = header.querySelector('input');
					return input ? input.value : `Setor ${Array.from(headers).indexOf(header)}`;
				});
		}


        function getFinalDemand() {
			const tbody = document.querySelector('#finalDemandInputs');
			const inputs = tbody.querySelectorAll('input[type="number"]');
			return Array.from(inputs).map(input => parseFloat(input.value) || 0);
		}


        function makeSquareMatrix(matrix) {
            const size = Math.max(matrix.length, matrix[0].length);
            return Array.from({ length: size }, (_, i) =>
                Array.from({ length: size }, (_, j) => (matrix[i] && matrix[i][j]) || 0)
            );
        }

        function adjustDemandVector(demand, size) {
            return Array.from({ length: size }, (_, i) => demand[i] || 0);
        }

function resetEconomy() {
    const confirmation = confirm("Tem certeza de que deseja resetar a economia? Todos os dados serão perdidos e a economia será restaurada para o estado inicial.");
    if (confirmation) {
        location.reload(); // Recarrega a página, restaurando todos os dados ao estado inicial
    }
}



function confirmClearTable() {
    const confirmation = confirm("Tem certeza de que deseja limpar a tabela? Todos os dados serão perdidos.");
    if (confirmation) {
        clearTable(); // Chama a função de limpeza se confirmado
    }
}


        function clearTable() {
    const rows = document.getElementById('inputTable').querySelectorAll('tbody tr');
    rows.forEach(row => {
        const cells = row.querySelectorAll('input[type="number"]');
        cells.forEach(cell => cell.value = '0');
    });

    // Limpa os valores de demanda e status de otimização
    const demandInputs = document.querySelectorAll('#finalDemandInputs input[type="number"]');
    demandInputs.forEach(input => input.value = '0');
    optimizedStatus = {};  // Resetar o status de otimização

    // Atualiza os botões "Otimizar" para o estado padrão
    const optimizeButtons = document.querySelectorAll('#finalDemandInputs button');
    optimizeButtons.forEach(button => button.style.backgroundColor = '');

    // Limpa os valores nas janelas modais de otimização
    if(null!=document.getElementById('productionGoal')){
		document.getElementById('productionGoal').value = '';
	}
    document.getElementById('workerLimit').value = '';
    document.getElementById('workerHours').value = '';
    document.getElementById('productionTime').value = '';

    // Limpa os dados de otimização armazenados para cada produto
    optimizationInputs = {};
    optimizationResults = {};

    // Limpa os resultados de "Planificar"
    document.getElementById('result').innerHTML = '';

    // Oculta o título "Planificação Otimizada" e a tabela
    isPlanified = false; // Marca que a planificação foi resetada
    togglePlanificationElements(); // Atualiza visibilidade
}


function formatDays(totalHours) {
    const days = Math.floor(totalHours / 24);
    const remainingHours = totalHours % 24; // Calcula as horas restantes que não completam um dia

    const years = Math.floor(days / 365);
    const remainingDaysAfterYears = days % 365;
    const months = Math.floor(remainingDaysAfterYears / 30);
    const remainingDaysAfterMonths = remainingDaysAfterYears % 30;
    const weeks = Math.floor(remainingDaysAfterMonths / 7);
    const remainingDays = remainingDaysAfterMonths % 7;

    const pluralize = (value, singular, plural) => value === 1 ? singular : plural;

    const parts = []; // Lista para armazenar as partes não nulas

    if (years > 0) parts.push(`${years} ${pluralize(years, "ano", "anos")}`);
    if (months > 0) parts.push(`${months} ${pluralize(months, "mês", "meses")}`);
    if (weeks > 0) parts.push(`${weeks} ${pluralize(weeks, "semana", "semanas")}`);
    if (remainingDays > 0) parts.push(`${remainingDays} ${pluralize(remainingDays, "dia", "dias")}`);
    if (remainingHours > 0) parts.push(`${remainingHours} ${pluralize(remainingHours, "hora", "horas")}`);

    return parts.join(", ");
}


let userLocation = null; // Variável para armazenar a localização do usuário
let userCity = "Localização não disponível"; // Cidade padrão para fallback

// Função para atualizar o conteúdo da barra com hora e localização
function fetchLocationAndUpdateInfoBar() {
    const infoText = document.getElementById('infoText');
    const now = new Date();
    const locale = 'pt-BR';

    // Formatar a data e hora
    const dia = now.getDate();
    const mes = now.toLocaleString(locale, { month: 'long' });
    const ano = now.getFullYear();
    const horas = now.getHours().toString().padStart(2, '0');
    const minutos = now.getMinutes().toString().padStart(2, '0');
    const segundos = now.getSeconds().toString().padStart(2, '0');

     // Determinar o título com base no pronome
    let title = '';

    // Atualizar a barra com os dados do conselho e hora local
    if (userIsLoggedIn) {
	
		const username = document.getElementById('username').value;
		const password = document.getElementById('password').value;
		if(null == user){
			user = users.find(u => u.username === username && u.password === password);
		}
	
		if (user.pronoun === 'feminino') {
            title = 'Conselheira';
        } else if (user.pronoun === 'masculino') {
            title = 'Conselheiro';
        } else {
            title = 'Conselheire';
        }
	
        infoText.innerHTML = `${title} ${user.username}, ${user.instance} ${user.preposition} ${user.jurisdiction}, ${dia} de ${mes} de ${ano}, ${horas}:${minutos}:${segundos} <button id="logoutButton" onclick="logout()">Sair</button>`;
    } else {
        // Caso não tenha dados completos, mostrar apenas o texto com a hora e localização
        infoText.innerHTML = `<button id="loginButton" onclick="showLoginSection()">Faça Login</button> ${dia} de ${mes} de ${ano}, ${horas}:${minutos}:${segundos}`;
    }
}


// Função para obter a localização apenas uma vez
function getUserLocation() {
    if (!navigator.geolocation) {
        // Caso o navegador não suporte geolocalização
        userCity = "Geolocalização não suportada";
        return;
    }

    // Solicitar localização do navegador apenas uma vez
    navigator.geolocation.getCurrentPosition(
        (position) => {
            const { latitude, longitude } = position.coords;

            // Obter cidade com geocodificação reversa
            fetch(`https://nominatim.openstreetmap.org/reverse?format=json&lat=${latitude}&lon=${longitude}`)
                .then(response => response.json())
                .then(data => {
                    userCity = data.address.city || data.address.town || data.address.village || "Localização desconhecida";
                })
                .catch(() => {
                    userCity = "Localização não disponível";
                });
        },
        () => {
            // Caso o usuário negue a permissão
            userCity = "Permissão negada";
        }
    );
}

// Inicializa a localização (chamada única)
getUserLocation();

// Atualiza a barra continuamente para exibir a hora atualizada
function updateInfoBar() {
    fetchLocationAndUpdateInfoBar();
}

// Inicializa a barra e atualiza a hora
setInterval(updateInfoBar, 1000);
updateInfoBar();


// Funções para abrir e fechar a modal
function openCopyableDataModal() {
    document.getElementById('copyableDataModal').style.display = 'flex'; // Exibe a modal
}

function closeCopyableDataModal() {
    document.getElementById('copyableDataModal').style.display = 'none'; // Fecha a modal
}

// Evento no botão para abrir a modal
document.getElementById('openCopyableDataModal').addEventListener('click', openCopyableDataModal);

// Função para embaralhar a lista de notícias
function shuffleArray(array) {
    for (let i = array.length - 1; i > 0; i--) {
        const j = Math.floor(Math.random() * (i + 1));
        [array[i], array[j]] = [array[j], array[i]];
    }
    return array;
}


function fetchNewsTitles() {
    // Dados estáticos simulando as notícias retornadas pela API
    const headlines = [
    "Vale do São Francisco (BA/PE): Produção de 963 mil toneladas de manga e 207,7 mil toneladas de uva de mesa.",
    "Chapada do Apodi (RN): Exportação de quase metade do melão nacional e 12% da melancia.",
    "Região Sul (PR, SC, RS): 96% da produção de uva industrial do Brasil, com destaque para vinhos e espumantes.",
    "Pará (Norte): Produção de 1,5 milhão de toneladas de açaí, representando 94% do total nacional.",
    "Centro-Oeste: Crescimento no cultivo de frutas nativas como guaraná e castanha-do-Brasil.",
    "Sudeste: Produção de 17,7 milhões de toneladas de laranja prevista para 2024.",
    "Sul da Bahia: Projeto de reflorestamento na APA do Pratigi recuperou 140 hectares e revitalizou 100 nascentes.",
    "Mata Atlântica (RJ): Projeto Onda Verde já plantou 2 milhões de mudas em 26 anos.",
    "Amazônia Legal: Reflorestamento de 30 milhões de árvores nativas em 25 áreas desmatadas.",
    "Cerrado (GO/MS/MT): 500 hectares restaurados no projeto Emas-Taquari, conectando parques e beneficiando 51 famílias.",
    "Indústria Eletroeletrônica (SP): Produção deve crescer 3% em 2024, com aumento de semicondutores e motores elétricos.",
    "Campinas (SP): Parques tecnológicos desenvolvendo novos sensores para agricultura e saúde.",
    "Norte e Nordeste: Crescimento de semicondutores para energia solar e hidrogênio verde.",
    "Sul do Brasil: Automação industrial impulsiona modernização de 60 fábricas em 2024.",
    "Região Centro-Oeste: Projetos de robótica colaborativa ampliam exportação de equipamentos industriais.",
    "Frente Oeste (RS): Desenvolvimento de infraestrutura digital e turismo inteligente com tecnologia.",
    "Bahia: Uso de tecnologia quântica em projetos industriais para soluções avançadas.",
    "São Paulo: Indústria de software cresce 8%, com destaque para inteligência artificial em saúde e logística.",
    "Amazônia: Restauração de ecossistemas com biotecnologia para 100 mil hectares até 2025.",
    "Ceará: Ampliação da fabricação de equipamentos para telecomunicações, com 5G liderando a transformação."
];


	const shuffledHeadlines = shuffleArray([...headlines]); // Embaralha as notícias
    const newsText = shuffledHeadlines.join(' - '); // Cria o texto para o letreiro
    const marquee = document.getElementById('newsMarquee');
    marquee.innerHTML = `
        <img src="https://i.postimg.cc/65gr9cjN/bandeiravermelhaanimada.gif" alt="Bandeira Vermelha">
        ${newsText}
    `;
	
}

// Chama a função imediatamente para carregar os dados na primeira vez
fetchNewsTitles();

function updateProductName(rowIndex, newName) {
    const demandRows = document.querySelectorAll('#finalDemandInputs tr');
	const sectorHeader = document.querySelector(`#inputTable thead tr th:nth-child(${rowIndex + 2}) input`);

    if (demandRows[rowIndex]) {
        const productCell = demandRows[rowIndex].querySelector('td:first-child');
        if (productCell) {
            productCell.textContent = newName; // Atualiza o nome do produto na tabela Demanda Final
        }
    }
    if (sectorHeader) {
        sectorHeader.value = `Produzir ${newName}`; // Atualiza o nome do setor
    }

    //showNotification(`Produto ${rowIndex + 1} atualizado para: ${newName}`, true);
}

function updateSectorName(colIndex, newName) {
    const thead = document.querySelector('#inputTable thead tr');
    const headerCell = thead.querySelectorAll('th')[colIndex + 1]; // Coluna começa no índice 1

    if (headerCell) {
        const input = headerCell.querySelector('input[type="text"]');
        if (input) {
            input.value = newName; // Atualiza o título da coluna
        }
    }

    //showNotification(`Setor ${colIndex + 1} atualizado para: ${newName}`, true);
}


document.getElementById('downloadDataButton').addEventListener('click', () => {
    try {
        const csvContent = generateCSV();
        downloadCSV(csvContent, 'dados_economia.csv');
    } catch (error) {
        console.error('Erro ao gerar o arquivo CSV:', error);
    }
});

function generateCSV() {
    const data = collectAllData();

    let csv = '';

    // Nomes dos Produtos
    csv += 'Produtos\n';
    csv += data.productNames.join(',') + '\n\n';

    // Matriz Tecnológica
    csv += 'Matriz Tecnológica\n';
    data.techMatrix.forEach((row, rowIndex) => {
        csv += `${data.productNames[rowIndex]},${row.map(value => value || 0).join(',')}\n`;
    });
    csv += '\n';

    // Demanda Final
    csv += 'Demanda Final\n';
    data.finalDemand.forEach((value, rowIndex) => {
        csv += `${data.productNames[rowIndex]},${value || 0}\n`;
    });
    csv += '\n';

    // Dados de Otimização
    csv += 'Otimização\n';
    for (const [index, inputs] of Object.entries(data.optimizationInputs)) {
        const values = [
            data.productNames[index] || '',
            inputs.workerLimit || 0,
            inputs.workerHours || 0,
            inputs.productionTime || 0,
            inputs.nightShift ? 'true' : 'false',
            inputs.weeklyScale || 0,
            optimizedStatus[index] ? 'true' : 'false'
        ];
        csv += values.join(',') + '\n';
    }
    csv += '\n';

    // Resultados da Planificação
    csv += 'Resultados da Planificação\n';
    for (const [index, results] of Object.entries(data.optimizationResults)) {
        const values = [
            data.productNames[index] || '',
            results.totalHours || 0,
            results.workersNeeded || 0,
            results.factoriesNeeded || 0,
            results.totalShifts || 0,
            results.minimumProductionTime || 0,
            results.totalEmploymentPeriod || ''
        ];
        csv += values.join(',') + '\n';
    }

    return csv;
}






function downloadCSV(content, filename) {
    const blob = new Blob([content], { type: 'text/csv;charset=utf-8;' });
    const link = document.createElement('a');
    link.href = URL.createObjectURL(blob);
    link.download = filename;
    link.click();
}


document.getElementById('uploadDataButton').addEventListener('click', () => {
    const fileInput = document.getElementById('uploadInput');
    fileInput.click();
});

document.getElementById('uploadInput').addEventListener('change', async (event) => {
    const file = event.target.files[0];
    if (file) {
        try {
            const content = await file.text();
            restoreDataFromCSV(content);
            console.info('Dados restaurados com sucesso!');
        } catch (error) {
            console.error('Erro ao restaurar os dados:', error);
            console.info('Ocorreu um erro ao restaurar os dados. Verifique o arquivo CSV.');
        }
    }
});

function restoreDataFromCSV(content) {
    const lines = content.split('\n').map(line => line.trim()).filter(line => line);
    let section = null;

    const data = {
        productNames: [],
        techMatrix: [],
        finalDemand: [],
        optimizationInputs: {},
        optimizationResults: {}
    };

    lines.forEach(line => {
        const cells = line.split(',');

        if (line === 'Produtos') {
            section = 'productNames';
        } else if (line === 'Matriz Tecnológica') {
            section = 'techMatrix';
        } else if (line === 'Demanda Final') {
            section = 'finalDemand';
        } else if (line === 'Otimização') {
            section = 'optimizationInputs';
        } else if (line === 'Resultados da Planificação') {
            section = 'optimizationResults';
        } else {
            if (section === 'productNames') {
                data.productNames = cells.map(name => name.trim());
            } else if (section === 'techMatrix') {
                if (cells.length > 1) {
                    const values = cells.slice(1).map(value => parseFloat(value) || 0);
                    data.techMatrix.push(values);
                }
            } else if (section === 'finalDemand') {
                if (cells.length === 2) {
                    const demand = parseFloat(cells[1]) || 0;
                    data.finalDemand.push(demand);
                }
            } else if (section === 'optimizationInputs') {
                const [
                    productName,
                    workerLimit,
                    workerHours,
                    productionTime,
                    nightShift,
                    weeklyScale,
                    optimized
                ] = cells;

                const productIndex = data.productNames.indexOf(productName);

                if (productIndex !== -1) {
                    const inputs = {
                        workerLimit: parseFloat(workerLimit) || 0,
                        workerHours: parseFloat(workerHours) || 0,
                        productionTime: parseFloat(productionTime) || 0,
                        nightShift: nightShift === 'true',
                        weeklyScale: parseInt(weeklyScale, 10) || 0
                    };

                    // Salvar os dados no objeto e processar se otimizados
                    data.optimizationInputs[productIndex] = inputs;
                    if (optimized === 'true') {
                        optimizationInputs[productIndex] = inputs;
                        saveOptimizationInputsForProduct(productIndex); // Chama a função para salvar e processar
                    }
                }
            }
        }
    });

    // Validação e ajuste de dados restaurados
    if (data.finalDemand.length !== data.productNames.length) {
        while (data.finalDemand.length < data.productNames.length) {
            data.finalDemand.push(0);
        }
    }

    // Redimensionar a tabela e carregar os dados
    resizeTableForData(data.productNames.length, data.techMatrix[0]?.length || 0);
    populateTechMatrix(data.techMatrix, data.productNames);
    populateFinalDemand(data.finalDemand);

	// Atualiza o status de otimização e os botões
    Object.keys(optimizationInputs).forEach(index => {
        const productIndex = parseInt(index, 10);
        const hasOptimization = isOptimizationDataComplete(productIndex);
        optimizedStatus[productIndex] = hasOptimization; // Define o status
        updateOptimizeButtonColor(productIndex); // Atualiza a cor do botão
    });

    // Executar a função de planificação automaticamente
    planify();

    console.info('Dados restaurados e planificados com sucesso!');
}

function saveOptimizationInputsForProduct(productIndex) {
    const inputs = optimizationInputs[productIndex];
    if (!inputs) return;

    // Salva os dados no objeto de otimização
    optimizationInputs[productIndex] = inputs;
    optimizedStatus[productIndex] = true;

    // Atualiza o botão na tabela "Demanda Final"
    updateOptimizeButtonColor(productIndex);

    // Recalcula a otimização para este produto
    performOptimization(productIndex);
}

function saveOptimizationInputsForProduct(productIndex) {
    const inputs = optimizationInputs[productIndex];
    if (!inputs) return;

    // Salva os dados no objeto de otimização
    optimizationInputs[productIndex] = inputs;
    optimizedStatus[productIndex] = true;

    // Atualiza o botão na tabela "Demanda Final"
    updateOptimizeButtonColor(productIndex);

    // Recalcula a otimização para este produto
    performOptimization(productIndex);

    // Atualiza os resultados da "Planificação Otimizada"
    const resultDiv = document.getElementById('result');
    if (resultDiv && resultDiv.innerHTML.trim() !== '') {
        planify(); // Reprocessa os dados da planificação
    }
}







function restoreFromCSV(content) {
    const lines = content.split('\n').map(line => line.trim()).filter(line => line);
    let section = null;

    const data = {
        productNames: [],
        techMatrix: [],
        finalDemand: [],
        optimizationInputs: {},
        optimizationResults: {}
    };

    lines.forEach(line => {
        if (line === 'Produtos') {
            section = 'productNames';
        } else if (line === 'Matriz Tecnológica') {
            section = 'techMatrix';
        } else if (line === 'Demanda Final') {
            section = 'finalDemand';
        } else if (line === 'Otimização') {
            section = 'optimizationInputs';
        } else if (line === 'Resultados da Planificação') {
            section = 'optimizationResults';
        } else {
            const cells = line.split(',');

            if (section === 'productNames') {
                data.productNames = cells;
            } else if (section === 'techMatrix') {
                const productName = cells[0];
                const values = cells.slice(1).map(Number);
                data.techMatrix.push(values);
                if (!data.productNames.includes(productName)) {
                    data.productNames.push(productName);
                }
            } else if (section === 'finalDemand') {
                const productName = cells[0];
                const value = Number(cells[1]);
                data.finalDemand.push(value);
            } else if (section === 'optimizationInputs') {
                const [productName, workerLimit, workerHours, productionTime, nightShift, weeklyScale] = cells;
                const productIndex = data.productNames.indexOf(productName);
                data.optimizationInputs[productIndex] = {
                    workerLimit: parseFloat(workerLimit),
                    workerHours: parseFloat(workerHours),
                    productionTime: parseFloat(productionTime),
                    nightShift: nightShift === 'true',
                    weeklyScale: parseInt(weeklyScale, 10)
                };
            } else if (section === 'optimizationResults') {
                const [
                    productName,
                    totalHours,
                    workersNeeded,
                    factoriesNeeded,
                    totalShifts,
                    minimumProductionTime,
                    totalEmploymentPeriod
                ] = cells;
                const productIndex = data.productNames.indexOf(productName);
                data.optimizationResults[productIndex] = {
                    totalHours: parseFloat(totalHours),
                    workersNeeded: parseInt(workersNeeded, 10),
                    factoriesNeeded: parseFloat(factoriesNeeded),
                    totalShifts: parseInt(totalShifts, 10),
                    minimumProductionTime: parseInt(minimumProductionTime, 10),
                    totalEmploymentPeriod
                };
            }
        }
    });

    // Restaurar os dados
    resizeTableForData(data.techMatrix.length, data.techMatrix[0]?.length || 0);
    populateTechMatrix(data.techMatrix, data.productNames);
    populateFinalDemand(data.finalDemand);
    optimizationInputs = data.optimizationInputs;
    optimizationResults = data.optimizationResults;
    planify(); // Recalcula os resultados
	
	// Atualiza os botões com base nos dados carregados
    Object.keys(optimizationInputs).forEach(index => {
        updateOptimizeButtonColor(parseInt(index, 10));
    });
	
}



function resizeTableForData(numRows, numCols) {
    document.getElementById('numRows').value = numRows;
    document.getElementById('numCols').value = numCols;
    resizeTable(); // Redimensiona a tabela usando a função existente
}






function populateTechMatrix(techMatrix, productNames) {
    const thead = document.getElementById('inputTable').querySelector('thead tr');
    const tbody = document.getElementById('inputTable').querySelector('tbody');

    // Atualizar os títulos das colunas
    thead.innerHTML = '<th>Produtos / Setor Produtivo</th>'; // Redefine o cabeçalho
    productNames.forEach(productName => {
        const sectorHeader = document.createElement('th');
        const sectorInput = document.createElement('input');
        sectorInput.type = 'text';
        sectorInput.value = `Produzir ${productName}`;
        sectorInput.readOnly = true; // Define como apenas leitura
		sectorHeader.appendChild(sectorInput);
        thead.appendChild(sectorHeader);
    });

    // Atualizar os dados da tabela
    tbody.innerHTML = ''; // Limpa a tabela existente
    techMatrix.forEach((row, rowIndex) => {
        const tr = document.createElement('tr');
        const productNameCell = document.createElement('td');
        const productInput = document.createElement('input');
        productInput.type = 'text';
        productInput.value = productNames[rowIndex];
		productInput.oninput = () => updateProductName(rowIndex, productInput.value);
        productNameCell.appendChild(productInput);
        tr.appendChild(productNameCell);

        row.forEach(value => {
            const cell = document.createElement('td');
            const input = document.createElement('input');
            input.type = 'number';
            input.value = value;
            cell.appendChild(input);
            tr.appendChild(cell);
        });

        tbody.appendChild(tr);
    });
}


function populateFinalDemand(finalDemand) {
    const demandContainer = document.getElementById('finalDemandInputs');
    demandContainer.innerHTML = ''; // Limpa a tabela antes de preencher

    finalDemand.forEach((demand, index) => {
        const row = document.createElement('tr');

        // Coluna do nome do produto
        const productNameCell = document.createElement('td');
        productNameCell.textContent = getProductNames()[index] || `Produto ${index + 1}`;
        row.appendChild(productNameCell);

        // Entrada de demanda
        const demandInputCell = document.createElement('td');
        const demandInput = document.createElement('input');
        demandInput.type = 'number';
        demandInput.value = demand;
        demandInput.id = `demand${index}`;
        demandInputCell.appendChild(demandInput);
        row.appendChild(demandInputCell);

        // Botão de ação
        const actionCell = document.createElement('td');
        const optimizeButton = document.createElement('button');
        optimizeButton.textContent = 'Otimizar';
        optimizeButton.onclick = () => openOptimizationModal(index); // Reatribuir o evento de clique
        actionCell.appendChild(optimizeButton);
        row.appendChild(actionCell);

        demandContainer.appendChild(row);

        // Atualizar a cor do botão com base no status de otimização
        updateOptimizeButtonColor(index);
    });
}


function collectAllData() {
    // Obter nomes dos produtos
    const productNames = getProductNames();

    // Obter dados da tabela "Matriz Tecnológica"
    const techMatrix = getTableData();

    // Obter dados da tabela "Demanda Final"
    const finalDemand = getFinalDemand();
	
	const instancePrepositionJurisdiction = user.instancePrepositionJurisdiction;

    return {
        productNames,       // Nomes dos produtos
        techMatrix,         // Dados da Matriz Tecnológica
        finalDemand,        // Dados da Demanda Final
        optimizationInputs, // Configurações de otimização (objeto global)
        optimizationResults, // Resultados da planificação (objeto global)
		instancePrepositionJurisdiction			//Instância + Preposição + Jurisdição
    };
}

function updateColumnTitles(productNames) {
    const headerRow = document.getElementById('inputTable').querySelector('thead tr');

    // Ignorar a primeira célula (que contém "Produtos / Setores Produtivos")
    const columnHeaders = headerRow.querySelectorAll('th');

    productNames.forEach((productName, index) => {
        const columnHeader = columnHeaders[index + 1]; // +1 para ignorar a primeira célula
        if (columnHeader) {
            const input = columnHeader.querySelector('input');
            if (input) {
                input.value = `Produzir ${productName}`; // Atualiza o título
                input.readOnly = true; // Configura como somente leitura
            }
        }
    });
}



//Salva os dados online
const binId = "67454301e41b4d34e45ab292";
const masterKey = "$2a$10$tw5ozlXgGiyo1kAB42FwPuMqkoLzG4FFYPsjwvSiPdegN//svmBSu";
const apiUrl = `https://api.jsonbin.io/v3/b/${binId}`;


function sendDataToJsonBin() {
    if (!userIsLoggedIn || !user) {
        showNotification("Você precisa estar logado para enviar dados.", false);
        return;
    }

    const instanceKey = user.instancePrepositionJurisdiction;

    const dataToSave = {
        inputTable: getTableData(),
        productNames: getProductNames(), // Salva os nomes dos produtos
        sectorNames: getSectorNames(),  // Salva os nomes dos setores
        finalDemand: getFinalDemand(),
        optimizationInputs,
        optimizationResults
    };

    fetch(apiUrl, {
        method: 'GET',
        headers: {
            'X-Master-Key': masterKey
        }
    })
        .then(response => response.json())
        .then(binData => {
            const record = binData.record || {};
            record[instanceKey] = {
                ...record[instanceKey],
                ...dataToSave
            };

            return fetch(apiUrl, {
                method: 'PUT',
                headers: {
                    'Content-Type': 'application/json',
                    'X-Master-Key': masterKey
                },
                body: JSON.stringify(record)
            });
        })
        .then(() => showNotification("Dados enviados com sucesso!", true))
        .catch(err => console.error("Erro ao enviar dados para o JSONBin:", err));
}




function fetchDataFromJsonBin() {

	// Reseta os dados anteriores antes de carregar novos dados
    previousTableData = [];

    if (!userIsLoggedIn || !user) {
        showNotification("Você precisa estar logado para receber dados.", false);
        return;
    }

	 // Limpa os dados antigos antes de carregar novos
    optimizationInputs = {}; // Reseta os inputs de otimização
    optimizationResults = {}; // Reseta os resultados de otimização
    optimizedStatus = {}; // Reseta o status dos botões de otimização

    const instanceKey = user.instancePrepositionJurisdiction;

    fetch(apiUrl, {
        method: 'GET',
        headers: {
            'X-Master-Key': masterKey
        }
    })
        .then(response => response.json())
        .then(binData => {
            const record = binData.record || {};
            const instanceData = record[instanceKey];

            if (instanceData) {
			
				 // Obter dimensões da matriz tecnológica
				const numProducts = instanceData.productNames?.length || 0;
				const numSectors = instanceData.sectorNames?.length || 0;

				// Atualizar os campos "Número de produtos" e "Número de Setores Produtivos"
				document.getElementById('numRows').value = numProducts;
				document.getElementById('numCols').value = numSectors;

				// Executar a função de redimensionar tabela
				resizeTable();
			
                fillTableWithData(instanceData.inputTable || []);
                setProductNames(instanceData.productNames || []);
                setSectorNames(instanceData.sectorNames || []);
                setFinalDemand(instanceData.finalDemand || []);
                optimizationInputs = instanceData.optimizationInputs || {};
                optimizationResults = instanceData.optimizationResults || {};
				
				synchronizeFinalDemandProducts();
				
				// Atualiza os botões de otimização de acordo com os novos dados
				updateAllOptimizeButtons();
				
				// Executa a planificação automaticamente após carregar os dados
				planify();
				
                showNotification("Dados recebidos com sucesso!", true);
				
				// Rolagem suave para a seção "Demanda Final"
					const demandTitle = document.getElementById('SecaoDemandaFinal'); // Seleciona o título pelo ID
					const infobar = document.getElementById('infoBar'); // Seleciona a infobar

					if (demandTitle) {
						const infobarHeight = infobar ? infobar.offsetHeight : 0; // Calcula a altura da infobar
						const demandTitlePosition = demandTitle.getBoundingClientRect().top + window.scrollY; // Posição do título na página
						const targetPosition = demandTitlePosition - infobarHeight; // Compensa a altura da infobar

						// Rola suavemente para a posição ajustada
						window.scrollTo({
							top: targetPosition,
							behavior: 'smooth',
						});
					}
				
            } else {
                showNotification("Nenhum dado encontrado para sua instância.", false);
            }
        })
        .catch(err => console.error("Erro ao receber dados do JSONBin:", err));
}



document.getElementById("sendDataButton").addEventListener("click", sendDataToJsonBin);

// Suponha um botão para restaurar dados
document.getElementById("fetchDataButton").addEventListener("click", () => {
    const binId = "67454301e41b4d34e45ab292"; //binID dos dados que se deseja restaurar
    if (binId) {
        fetchDataFromJsonBin(binId);
    }
});

function restoreDataFromJSON(data) {
    try {
	
		// Determina o número de produtos e setores com base nos dados recebidos
        const numRows = data.productNames.length;
        const numCols = data.techMatrix[0]?.length || 0;

        // Atualiza os valores dos inputs do Tamanho da Economia
        document.getElementById('numRows').value = numRows;
        document.getElementById('numCols').value = numCols;

        // Redimensiona a tabela principal
        resizeTable();

        // Preenche os dados recebidos na interface
        const tbody = document.getElementById('inputTableBody');
        tbody.innerHTML = '';

        data.productNames.forEach((name, rowIndex) => {
            const row = document.createElement('tr');

            // Nome do produto
            const productNameCell = document.createElement('td');
            const productInput = document.createElement('input');
            productInput.type = 'text';
            productInput.value = name;
            productInput.oninput = (e) => updateProductName(rowIndex, e.target.value);
            productNameCell.appendChild(productInput);
            row.appendChild(productNameCell);

            // Dados da Matriz Tecnológica
            data.techMatrix[rowIndex].forEach(value => {
                const cell = document.createElement('td');
                const input = document.createElement('input');
                input.type = 'number';
                input.value = value;
                cell.appendChild(input);
                row.appendChild(cell);
            });

            tbody.appendChild(row);
        });

        // Atualiza a tabela de Demanda Final
        const demandInputsContainer = document.getElementById('finalDemandInputs');
        demandInputsContainer.innerHTML = '';

        data.finalDemand.forEach((value, index) => {
            const demandRow = document.createElement('tr');

            // Nome do produto
            const productNameCell = document.createElement('td');
            productNameCell.textContent = data.productNames[index];
            demandRow.appendChild(productNameCell);

            // Valor da demanda
            const demandInputCell = document.createElement('td');
            const demandInput = document.createElement('input');
            demandInput.type = 'number';
            demandInput.value = value;
            demandInput.id = `demand${index}`;
            demandInputCell.appendChild(demandInput);
            demandRow.appendChild(demandInputCell);

            // Botão de otimização
            const buttonCell = document.createElement('td');
            const button = document.createElement('button');
            button.textContent = 'Otimizar';
            button.onclick = () => openOptimizationModal(index);
            buttonCell.appendChild(button);
            demandRow.appendChild(buttonCell);

            demandInputsContainer.appendChild(demandRow);
        });

        // Preenche os dados de "Parâmetros de Otimização" para os produtos
        Object.keys(data.optimizationInputs).forEach(index => {
            const productIndex = parseInt(index, 10);
            const inputs = data.optimizationInputs[productIndex];

            if (inputs) {
                optimizationInputs[productIndex] = {
                    workerLimit: inputs.workerLimit || 0,
                    workerHours: inputs.workerHours || 0,
                    productionTime: inputs.productionTime || 0,
                    nightShift: inputs.nightShift || false,
                    weeklyScale: inputs.weeklyScale || 0
                };
            }
        });

        // Atualiza o status de otimização e os botões
        Object.keys(optimizationInputs).forEach(index => {
            const productIndex = parseInt(index, 10);
            const hasOptimization = isOptimizationDataComplete(productIndex);
            optimizedStatus[productIndex] = hasOptimization; // Define o status
            updateOptimizeButtonColor(productIndex); // Atualiza a cor do botão
        });

        console.info('Dados restaurados com sucesso!');
		
		// Chama a função planify automaticamente após carregar os dados
        planify();
		
    } catch (error) {
        console.error('Erro ao restaurar os dados:', error);
    }
}



function convertJSONToCSV(data) {
    let csv = "";

    // Nomes dos Produtos
    csv += "Produtos\n";
    csv += data.productNames.join(",") + "\n\n";

    // Matriz Tecnológica
    csv += "Matriz Tecnológica\n";
    data.techMatrix.forEach((row, rowIndex) => {
        csv += `${data.productNames[rowIndex]},${row.map(value => value || 0).join(",")}\n`;
    });
    csv += "\n";

    // Demanda Final
    csv += "Demanda Final\n";
    data.finalDemand.forEach((value, rowIndex) => {
        csv += `${data.productNames[rowIndex]},${value || 0}\n`;
    });
    csv += "\n";

    // Dados de Otimização
    if (data.optimizationInputs) {
        csv += "Otimização\n";
        for (const [index, inputs] of Object.entries(data.optimizationInputs)) {
            const values = [
                data.productNames[index] || "",
                inputs.workerLimit || 0,
                inputs.workerHours || 0,
                inputs.productionTime || 0,
                inputs.nightShift ? "true" : "false",
                inputs.weeklyScale || 0,
                "true" // Supondo que os dados de JSON incluem otimizações feitas
            ];
            csv += values.join(",") + "\n";
        }
        csv += "\n";
    }

    // Resultados da Planificação
    if (data.optimizationResults) {
        csv += "Resultados da Planificação\n";
        for (const [index, results] of Object.entries(data.optimizationResults)) {
            const values = [
                data.productNames[index] || "",
                results.totalHours || 0,
                results.workersNeeded || 0,
                results.factoriesNeeded || 0,
                results.totalShifts || 0,
                results.minimumProductionTime || 0,
                results.totalEmploymentPeriod || ""
            ];
            csv += values.join(",") + "\n";
        }
    }

    return csv;
}

function isOptimizationDataComplete(productIndex) {
    const inputs = optimizationInputs[productIndex];
    if (!inputs) return false;

    return (
        inputs.workerLimit > 0 &&
        inputs.workerHours > 0 &&
        inputs.productionTime > 0 &&
        inputs.weeklyScale > 0
    );
}

// Função para mostrar os campos adicionais quando o Instância é selecionado
    function showFields() {
        const select = document.getElementById('instance');
        const additionalFields = document.getElementById('additionalFields');
        
        if (select.value) {
            additionalFields.style.display = 'flex'; // Exibe os campos adicionais
        } else {
            additionalFields.style.display = 'none'; // Oculta os campos adicionais
        }
    }

    // Função para mostrar ou ocultar a seção de Login
	   function showLoginSection() {
		const loginSection = document.getElementById("loginSection");
		loginSection.style.display = "block"; // Torna a seção de login visível
		const loginButton = document.getElementById("loginButton");
		loginButton.style.display = "none"; // Oculta o botão "Faça Login"
		// Ocultar os campos de registro, caso estejam visíveis
		document.getElementById('registrationFields').style.display = 'none';
		
		// Rola a página para o topo
        
		// Rola suavemente para o topo da página
		window.scrollTo({
			top: 0,
			behavior: 'smooth',
		});
		
		const usernameField = document.getElementById('username');
		usernameField.focus(); // Move o cursor para o campo "Nome de Usuário"
		
		
		
	}

    // Manter os dados inseridos no formulário quando clicar em "Faça Login"
    document.getElementById("loginButton").addEventListener("click", showLoginSection);

// Função para mostrar o campo de jurisdição quando uma opção é selecionada
    function showJurisdiction() {
        const select = document.getElementById('instance');
        const jurisdictionContainer = document.getElementById('jurisdictionContainer');
        
        // Exibe o campo apenas se uma opção válida for selecionada
        if (select.value) {
            jurisdictionContainer.style.display = 'flex'; // Exibe o campo com layout flex
            jurisdictionContainer.style.alignItems = 'center'; // Centraliza o rótulo e o campo
        } else {
            jurisdictionContainer.style.display = 'none'; // Oculta o campo
        }
    }

    // Função para atualizar o texto do conselho
    function updateCouncilText(event) {
        if (event.key === "Enter") {
            event.preventDefault(); // Impede comportamento padrão do Enter

            const instance = document.getElementById("instance").value;
            const jurisdiction = document.getElementById("jurisdiction").value.trim();
            const preposition = document.getElementById("preposition").value;
            const infoText = document.getElementById("infoText");

            if (instance && jurisdiction && preposition) {
                const now = new Date();
                const locale = 'pt-BR';
                const dia = now.getDate();
                const mes = now.toLocaleString(locale, { month: 'long' });
                const ano = now.getFullYear();
                const horas = now.getHours().toString().padStart(2, '0');
                const minutos = now.getMinutes().toString().padStart(2, '0');
                const segundos = now.getSeconds().toString().padStart(2, '0');

                infoText.innerHTML = `Seu Conselho: ${instance} ${preposition} ${jurisdiction}, ${dia} de ${mes} de ${ano}, ${horas}:${minutos}:${segundos}`;
            } else {
                showNotification("Por favor, preencha todos os campos obrigatórios.", false);
            }
        }
    }

    // Adiciona o evento de Enter no campo de jurisdição
    document.getElementById("jurisdiction").addEventListener("keydown", updateCouncilText);

    // Mostra os campos adicionais ao selecionar o Instância
    document.getElementById("instance").addEventListener("change", showFields);

// Exibe os campos de registro ao clicar no botão "Cadastre-se"
function showRegistrationFields() {
    const registrationFields = document.getElementById('registrationFields');
    registrationFields.style.display = 'block'; // Exibe os campos
}

async function handleLogin() {
	const usernameField = document.getElementById('username');
    const username = usernameField.value.trim();
    const password = document.getElementById('password').value.trim();

    if (!username || !password) {
        showNotification('Preencha todos os campos de login.', false);
        return;
    }

	 // Exibe a div "logado"
     document.getElementById('logado').style.display = 'block'; // Torna visível
	
	// Aplica a classe 'logged-in' ao #globeContainer para aplicar o estilo de login
        const globeContainer = document.getElementById('globeContainer');
        globeContainer.classList.add('logged-in'); // Adiciona a classe para alinhamento à direita

    try {
        // Buscar dados do JSONBin
        const response = await fetch(apiUrl, {
            headers: {
                'Content-Type': 'application/json',
                'X-Master-Key': masterKey
            }
        });
        const data = await response.json();

        // Verifica se o usuário existe e a senha corresponde
        user = data.record.users.find(
            user => user.username === username && user.password === password
        );

        if (user) {
            // Define os dados globais do usuário logado
            userIsLoggedIn = true;
            user = {
                username: user.username,
                instance: user.instance,
                pronoun: user.pronoun,
                jurisdiction: user.jurisdiction,
                preposition: user.preposition,
                instancePrepositionJurisdiction: user.instancePrepositionJurisdiction
            };

            // Realize outras ações de login aqui, se necessário
			
			if (user.pronoun === 'feminino') {
				showNotification(`Bem-vinda, ${user.username}!`, true);
			} else if (user.pronoun === 'masculino') {
				showNotification(`Bem-vindo, ${user.username}!`, true);
			} else {
				showNotification(`Bem-vinde, ${user.username}!`, true);
			}
			
			// Oculta a seção de login
			document.getElementById('loginSection').style.display = 'none';
			userIsLoggedIn = true;
			document.getElementById('sendDataButton').style.display = 'inline-block'; // Exibe o botão para enviar dados
			
			// Chama automaticamente a função que recebe os dados online
			setTimeout(() => {
				fetchDataFromJsonBin();
			}, 1000);
			
			} else {
				showNotification('Usuário ou senha inválidos.', false);
			}
    } catch (error) {
        console.error('Erro ao fazer login:', error);
        showNotification('Erro ao autenticar. Tente novamente mais tarde.', false);
    }
}


async function handleRegister() {
    const username = document.getElementById('username').value.trim();
    const password = document.getElementById('password').value.trim();
    const instance = document.getElementById('instance').value;
    const pronoun = document.getElementById('pronoun').value;
    const jurisdiction = document.getElementById('jurisdiction').value.trim();
    const preposition = document.getElementById('preposition').value;

    // Combina instance, preposition e jurisdiction
    const instancePrepositionJurisdiction = `${instance} ${preposition} ${jurisdiction}`;

    if (!username || !password || !instance || !jurisdiction || !preposition || !pronoun) {
        showNotification('Preencha todos os campos corretamente.', false);
        return;
    }

    try {
        // Buscar dados existentes no JSONBin
        const response = await fetch(apiUrl, {
            headers: {
                'Content-Type': 'application/json',
                'X-Master-Key': masterKey
            }
        });
        const data = await response.json();

        // Certifique-se de que a chave "users" exista no objeto
        if (!data.record.users) {
            data.record.users = [];
        }

        // Verifica se o nome de usuário já está registrado
        if (data.record.users.some(user => user.username === username)) {
            showNotification('Nome de usuário já registrado. Escolha outro.', false);
            return;
        }

        // Adiciona o novo usuário com todos os dados
        data.record.users.push({
            username,
            password,
            instance,
            pronoun,
            jurisdiction,
            preposition,
            instancePrepositionJurisdiction
        });

        // Salva de volta no JSONBin
        await fetch(apiUrl, {
            method: 'PUT',
            headers: {
                'Content-Type': 'application/json',
                'X-Master-Key': masterKey
            },
            body: JSON.stringify(data.record)
        });

        showNotification('Usuário registrado com sucesso!', true);
    } catch (error) {
        console.error('Erro ao salvar usuário:', error);
        showNotification('Erro ao registrar usuário. Tente novamente mais tarde.', false);
    }
}


function displaySuccessMessage(message) {
    const successBox = document.getElementById("successBox");
    successBox.textContent = message;
    successBox.style.top = "10px";
    successBox.style.opacity = "1";

    setTimeout(() => {
        successBox.style.top = "-50px";
        successBox.style.opacity = "0";
    }, 3000); // Oculta a mensagem após 3 segundos
}

function logout() {
    userIsLoggedIn = false; // Altere o estado do usuário para deslogado
	
	document.getElementById('sendDataButton').style.display = 'none'; // Oculta o botão de enviar dados

	let title;
	if (user.pronoun === 'feminino') {
            title = 'Conselheira';
        } else if (user.pronoun === 'masculino') {
            title = 'Conselheiro';
        } else {
            title = 'Conselheire';
        }

	showNotification(`Até a próxima, ${title} ${user.username}!`, true); // Mensagem de confirmação
	
	// Limpar os campos do formulário
    document.getElementById('username').value = '';
    document.getElementById('password').value = '';
    document.getElementById('instance').value = '';
    document.getElementById('pronoun').value = '';
    document.getElementById('jurisdiction').value = '';
    document.getElementById('preposition').value = '';
	clearTable();
	user = null;
	
    updateInfoBar(); // Atualiza a barra de informações para refletir o estado de logout
	
	// Rola suavemente para o topo da página
    window.scrollTo({
        top: 0,
        behavior: 'smooth',
    });
	
	// Esconde a div "logado"
    document.getElementById('logado').style.display = 'none'; // Torna invisível
	
	 // Remove a classe 'logged-in' do #globeContainer para voltar ao alinhamento centralizado
    const globeContainer = document.getElementById('globeContainer');
    globeContainer.classList.remove('logged-in'); // Remove a classe para voltar ao centro
	
}

function showNotification(message, isSuccess) {
    const notificationBox = document.getElementById('successBox');
    notificationBox.textContent = message; // Define a mensagem
    notificationBox.style.opacity = '1'; // Torna visível
    notificationBox.style.top = '10px'; // Move para uma posição visível

	// Ajusta a cor de fundo com base no tipo de mensagem
    if (isSuccess) {
        notificationBox.style.backgroundColor = 'rgba(0, 255, 0, 0.8)'; // Verde para mensagens de sucesso
		notificationBox.style.color = 'rgba(255, 255, 255, 1)'; // Verde para mensagens de sucesso
    } else {
        notificationBox.style.backgroundColor = 'rgba(255, 255, 0, 0.8)'; // Amarelo amarronzado para mensagens de erro/atenção
		notificationBox.style.color = 'rgba(70, 0, 0, 1)'; // Verde para mensagens de sucesso
    }

    // Oculta a mensagem após 3 segundos
    setTimeout(() => {
        notificationBox.style.opacity = '0'; // Torna invisível
        notificationBox.style.top = '-50px'; // Move para fora da tela
    }, 3000);
}

// Manipulador para pressionar "Enter" nos campos de Login ou Cadastre-se
document.addEventListener('keydown', function(event) {
    if (event.key === 'Enter') {
        const activeElement = document.activeElement; // Elemento que está em foco
        const loginSection = document.getElementById('loginSection');
        const registerFields = document.getElementById('registrationFields');

        // Verifica se a seção de Login está visível
        if (loginSection && loginSection.style.display !== 'none') {
		    // Caso esteja no modo de Cadastro
            if (registerFields && registerFields.style.display === 'block') {
                // Verifica se o foco está em um dos campos de Cadastro
                if (activeElement.id === 'instance' || 
                    activeElement.id === 'pronoun' || 
                    activeElement.id === 'jurisdiction' || 
                    activeElement.id === 'preposition') {
                    event.preventDefault(); // Impede o comportamento padrão do Enter
                    handleRegister(); // Simula o clique no botão "Cadastrar"
                    return;
                }
            }

            // Verifica se o foco está nos campos de Nome de Usuário ou Senha
            if (activeElement.id === 'username' || activeElement.id === 'password') {
                event.preventDefault(); // Impede o comportamento padrão do Enter
                //document.getElementById('loginButton').click(); // Simula o clique no botão "Entrar"
				handleLogin();
            }
        }
    }
});

let marker, camera, label; // Declare as variáveis no escopo global

function initSmallGlobe() {
    // Seleciona o contêiner para a animação
    const globeContainer = document.getElementById('globeContainer');

    // Configurações iniciais da cena
    const scene = new THREE.Scene();
    camera = new THREE.PerspectiveCamera(50, 1, 0.1, 1000);
    const renderer = new THREE.WebGLRenderer({ alpha: true }); // Fundo transparente
    renderer.setSize(300, 300); // Tamanho fixo do globo
    globeContainer.appendChild(renderer.domElement);

    // Adiciona a esfera da Terra
    const textureLoader = new THREE.TextureLoader();
    const earthTexture = textureLoader.load('https://i.postimg.cc/90NWNd6t/textura-Terra.jpg');
	
	
    const earthGeometry = new THREE.SphereGeometry(1, 32, 32);
    const earthMaterial = new THREE.MeshStandardMaterial({ map: earthTexture });
    const earth = new THREE.Mesh(earthGeometry, earthMaterial);

    // Corrige a orientação da textura
    //earth.rotation.x = Math.PI; // Gira 180 graus para alinhar corretamente


	// Ajuste manual da rotação
	//earth.rotation.y = THREE.MathUtils.degToRad(80); // Corrigir longitude

    scene.add(earth);

    // Adiciona luzes
    const ambientLight = new THREE.AmbientLight(0xffffff, 0.8);
    scene.add(ambientLight);
    const pointLight = new THREE.PointLight(0xffffff, 0.6);
    pointLight.position.set(5, 3, 5);
    scene.add(pointLight);

    // Configura a posição inicial da câmera
    camera.position.z = 3;

    // Adiciona o marcador vermelho para a localização do usuário
    navigator.geolocation.getCurrentPosition(function (position) {
        const latitude = position.coords.latitude;
        const longitude = position.coords.longitude;

		let ajusteManualDeLongitude = -99; //Ajuste para calibração da Longitude do Marcador, em graus

        // Converter latitude e longitude para coordenadas 3D
        const phi = (90 - latitude) * (Math.PI / 180); // Latitude
        const theta = (longitude + 180 + ajusteManualDeLongitude) * (Math.PI / 180); // Longitude

const loader = new THREE.TextureLoader();
const globeRadius = 1; // Substitua pelo raio real do globo (exemplo: 1 para THREE.SphereGeometry(1, ...))
const displacement = 0.1; // Ajuste o deslocamento para fora do globo

loader.load('https://i.postimg.cc/65gr9cjN/bandeiravermelhaanimada.gif', function (texture) {
    // Criar a geometria da bandeira (um plano)
    const planeGeometry = new THREE.PlaneGeometry(0.2, 0.2); // Ajuste o tamanho da bandeira
    const planeMaterial = new THREE.MeshBasicMaterial({
		map: texture,
		transparent: true,
		side: THREE.DoubleSide // Garante que a bandeira seja visível dos dois lados
	});
    marker = new THREE.Mesh(planeGeometry, planeMaterial); // Armazena na variável global

    // Posicionar a bandeira fora do globo
    marker.position.set(
        (Math.sin(phi) * Math.cos(theta)) * (globeRadius + displacement),
        (Math.cos(phi)) * (globeRadius + displacement),
        (Math.sin(phi) * Math.sin(theta)) * (globeRadius + displacement)
    );

    // Vetor que aponta para o centro do globo
	const center = new THREE.Vector3(0, 0, 0);
	const directionToCenter = center.clone().sub(marker.position).normalize();

	// Alinhar a bandeira com a superfície
	const upVector = new THREE.Vector3(0, -1, 0); // Vetor "para cima" da bandeira
	const quaternion = new THREE.Quaternion().setFromUnitVectors(upVector, directionToCenter);
	marker.setRotationFromQuaternion(quaternion);
	

    // Adicionar a bandeira ao globo
    earth.add(marker);
});





        // Usar a API de Geocodificação Reversa para obter o nome da cidade
        const geocodeUrl = `https://nominatim.openstreetmap.org/reverse?format=json&lat=${latitude}&lon=${longitude}&addressdetails=1&zoom=18`;

        fetch(geocodeUrl)
            .then(response => response.json())
            .then(data => {
                // Tenta diferentes campos para o nome da cidade
                const city = data.address.city || data.address.town || data.address.village || "Cidade desconhecida";
				const state = data.address.state || data.address.region;
                const country = data.address.country;

                // Criar um rótulo HTML para a localização no globo
                label = document.createElement('div');
                label.innerHTML = `${city}, <br>${state}, <br>${country}`;
                label.style.position = 'absolute';
                label.style.fontSize = '12px';
                label.style.fontWeight = 'bold';
				label.style.backgroundColor = 'rgba(255, 255, 255, 0.7)'; // Fundo branco transparente
				label.style.color = '#8B0000'; // Texto vermelho escuro
				label.style.padding = '5px 10px'; // Espaçamento interno
				label.style.borderRadius = '5px'; // Bordas arredondadas
				label.style.textAlign = 'center'; // Centraliza o texto horizontalmente
                label.style.pointerEvents = 'none'; // Evita que o rótulo interfira com interações do globo
                label.style.transform = 'translateX(-50%)'; // Centraliza o rótulo

                // Posicionar o rótulo em cima do ponteiro (marcador)
                globeContainer.appendChild(label);
                
                // Função para atualizar a posição do rótulo com base na rotação
                function updateLabelPosition() {
					const vector = new THREE.Vector3();
					const canvasBounds = renderer.domElement.getBoundingClientRect();

					// Posição da bandeira no mundo 3D
					vector.setFromMatrixPosition(marker.matrixWorld);

					// Converte a posição 3D para 2D (tela)
					vector.project(camera);

					// Converte para coordenadas de pixel no canvas
					const x = (vector.x * 0.5 + 0.5) * canvasBounds.width;
					const y = (1 - (vector.y * 0.5 + 0.5)) * canvasBounds.height;

					// Posiciona o rótulo acima da bandeira (ajuste "y" para subir um pouco)
					label.style.left = `${x}px`;
					label.style.top = `${y - 100}px`; // Move o rótulo um pouco para cima
				}

                // Função para converter coordenadas 3D para coordenadas da tela
                function getScreenPosition(position, camera, renderer) {
                    const vector = position.clone().project(camera);
                    const x = (vector.x * 0.5 + 0.5) * renderer.domElement.width;
                    const y = (vector.y * -0.5 + 0.5) * renderer.domElement.height;
                    return { x, y };
                }

                // Atualiza a posição do rótulo durante a animação
                function animate() {
                    requestAnimationFrame(animate);
                     // Atualize a posição do rótulo
					updateLabelPosition();
                }

                animate();
            })
            .catch(error => {
                console.error('Erro ao obter o nome da cidade:', error);
            });
    }, function (error) {
        console.error('Erro ao obter localização:', error);
    });

    // Função de animação
    function animate() {
        requestAnimationFrame(animate);
        earth.rotation.y += 0.005; // Velocidade de rotação
		
		renderer.render(scene, camera);
    }

    animate();
}

function fillTableWithData(inputTableData) {
    const tbody = document.querySelector('#inputTable tbody');
    const thead = document.querySelector('#inputTable thead tr');

    // Limpa a tabela existente
    tbody.innerHTML = '';
    thead.innerHTML = '<th>Produtos / Setores Produtivos</th>';

    if (inputTableData.length === 0) {
        showNotification("Tabela vazia recebida, nenhuma alteração feita.", false);
        return;
    }

    // Atualiza os cabeçalhos da tabela com base no número de colunas
    const numCols = inputTableData[0].length;
    for (let j = 0; j < numCols; j++) {
        const sectorHeader = document.createElement('th');
        const sectorInput = document.createElement('input');
        sectorInput.type = 'text';
        sectorInput.value = `Setor ${j + 1}`;
        sectorInput.oninput = () => updateSectorName(j, sectorInput.value);
        sectorHeader.appendChild(sectorInput);
        thead.appendChild(sectorHeader);
    }

    // Preenche a tabela com os dados recebidos
    inputTableData.forEach((row, rowIndex) => {
        const tableRow = document.createElement('tr');

        // Adiciona uma célula para o nome do produto
        const productNameCell = document.createElement('td');
        const productInput = document.createElement('input');
        productInput.type = 'text';
        productInput.value = `Produto ${rowIndex + 1}`;
        productInput.oninput = () => updateProductName(rowIndex, productInput.value);
        productNameCell.appendChild(productInput);
        tableRow.appendChild(productNameCell);

        // Preenche os valores das colunas
        row.forEach(value => {
            const cell = document.createElement('td');
            const input = document.createElement('input');
            input.type = 'number';
            input.value = value || 0;
            cell.appendChild(input);
            tableRow.appendChild(cell);
        });

        tbody.appendChild(tableRow);
    });

    //showNotification("Tabela preenchida com os dados recebidos.", true);
}


function setFinalDemand(finalDemandData) {
    const tbody = document.getElementById('finalDemandInputs');
    const rows = tbody.querySelectorAll('tr');

    // Certifica-se de que o número de entradas de demanda corresponda ao número de linhas
    rows.forEach((row, index) => {
        const input = row.querySelector('input[type="number"]');
        input.value = finalDemandData[index] !== undefined ? finalDemandData[index] : 0;
    });

    showNotification("Demanda final atualizada com os dados recebidos.", true);
}

function synchronizeFinalDemandProducts() {
    const productRows = document.querySelectorAll('#inputTable tbody tr');
    const demandRows = document.querySelectorAll('#finalDemandInputs tr');

    productRows.forEach((productRow, index) => {
        const productName = productRow.querySelector('td:first-child input').value;
        if (demandRows[index]) {
            demandRows[index].querySelector('td:first-child').textContent = productName;
        }
    });
}

function updateAllOptimizeButtons() {
    const demandRows = document.querySelectorAll('#finalDemandInputs tr');
    
    demandRows.forEach((row, index) => {
        updateOptimizeButtonColor(index); // Atualiza a cor do botão com base nos novos dados
    });
}

// Função para sincronizar o nome do produto na tabela "Demanda Final" e no título da coluna
function syncProductName(index, productName) {
    // Sincroniza o nome na coluna da tabela "Demanda Final"
    const demandRow = document.querySelector(`#finalDemandInputs tr:nth-child(${index + 1}) td:first-child`);
    demandRow.textContent = productName;

    // Sincroniza o título da coluna do setor produtivo
    const sectorHeader = document.querySelector(`#inputTable thead th:nth-child(${index + 2}) input`);
    if (sectorHeader) {
        sectorHeader.value = `Produzir ${productName}`;
    }
}

    </script>
</body>
</html>
