// Comparação de diferentes sistemas de módulos

// 1. ES MODULES (ESM) - Padrão oficial do JavaScript
// arquivo: utils.js
export const PI = 3.14159;
export function calcularArea(raio) {
    return PI * raio * raio;
}

export default function saudacao(nome) {
    return `Olá, ${nome}!`;
}

// arquivo: index.js
import saudacao, { PI, calcularArea } from './utils.js';

console.log(saudacao('João'));
console.log('Área:', calcularArea(5));

// Importação com alias
import { calcularArea as area } from './utils.js';

// Importação de tudo como namespace
import * as Utils from './utils.js';

// Importação dinâmica (ES2020+)
async function carregarModuloDinamicamente() {
    const modulo = await import('./utils.js');
    return modulo.calcularArea(10);
}

// 2. COMMONJS - Usado em Node.js (síncrono)
// arquivo: utils.cjs
const PI = 3.14159;

function calcularArea(raio) {
    return PI * raio * raio;
}

function saudacao(nome) {
    return `Olá, ${nome}!`;
}

// Exportações nomeadas (formato alternativo)
exports.PI = PI;
exports.calcularArea = calcularArea;

// Exportação padrão
module.exports = saudacao;

// OU exportar tudo de uma vez
// module.exports = {
//     PI,
//     calcularArea,
//     saudacao
// };

// arquivo: index.cjs
const saudacao = require('./utils.cjs');
const { PI, calcularArea } = require('./utils.cjs');

// Importação dinâmica no CommonJS
const caminho = './utils.cjs';
const moduloDinamico = require(caminho);

// 3. AMD (Asynchronous Module Definition) - Para navegadores antigos
// arquivo: utils.js (AMD)
define(['require', 'exports'], function(require, exports) {
    const PI = 3.14159;
    
    function calcularArea(raio) {
        return PI * raio * raio;
    }
    
    // Exportar funções
    exports.PI = PI;
    exports.calcularArea = calcularArea;
});

// Utilização AMD
require(['utils'], function(utils) {
    console.log('Área:', utils.calcularArea(5));
});

// 4. UMD (Universal Module Definition) - Compatibilidade multiplataforma
(function (root, factory) {
    if (typeof define === 'function' && define.amd) {
        // AMD
        define(['jquery'], factory);
    } else if (typeof module === 'object' && module.exports) {
        // CommonJS
        module.exports = factory(require('jquery'));
    } else {
        // Browser globals
        root.libName = factory(root.jQuery);
    }
}(typeof self !== 'undefined' ? self : this, function ($) {
    // Conteúdo da biblioteca
    return {
        init: function() {
            // Implementação
        }
    };
}));

// 1. Exportações nomeadas
// math-utils.js
export const E = 2.718;
export const PI = 3.14159;

export function somar(a, b) {
    return a + b;
}

export function subtrair(a, b) {
    return a - b;
}

// Pode exportar tudo de uma vez
export {
    E,
    PI,
    somar as adicao,  // com alias
    subtrair
};

// 2. Exportação padrão (apenas uma por módulo)
// calculator.js
import { somar, subtrair } from './math-utils.js';

class Calculator {
    constructor() {
        this.history = [];
    }
    
    add(a, b) {
        const result = somar(a, b);
        this.history.push({ operation: 'add', a, b, result });
        return result;
    }
    
    subtract(a, b) {
        const result = subtrair(a, b);
        this.history.push({ operation: 'subtract', a, b, result });
        return result;
    }
    
    getHistory() {
        return [...this.history];
    }
}

// Apenas uma exportação padrão por arquivo
export default Calculator;

// 3. Importações variadas
// app.js
import Calculator from './calculator.js'; // Importação padrão
import { E, PI, somar } from './math-utils.js'; // Importações nomeadas
import { somar as somarNums } from './math-utils.js'; // Com alias
import * as MathUtils from './math-utils.js'; // Namespace import
import Calculator2, { PI as PI_CONST } from './calculator.js'; // Ambos

// Importação dinâmica
async function carregarFerramentasMatematicas() {
    const { somar, subtrair, PI } = await import('./math-utils.js');
    return { somar, subtrair, PI };
}

// Re-exportações
// math-extended.js
export { default as Calculadora } from './calculator.js';
export { somar, subtrair, E } from './math-utils.js';

// Renomear durante re-exportação
export { PI as NumeroPI } from './math-utils.js';

// Exportar tudo de outro módulo
export * from './math-utils.js';

// 4. Exemplos práticos de organização de módulos
// config.js
export const API_BASE_URL = 'https://api.exemplo.com';
export const TIMEOUT = 5000;

// config.js (exportação de objeto de configuração)
export const config = {
    apiUrl: API_BASE_URL,
    timeout: TIMEOUT,
    headers: {
        'Content-Type': 'application/json'
    }
};

// api-client.js
import { API_BASE_URL, TIMEOUT } from './config.js';

class ApiClient {
    constructor(baseUrl = API_BASE_URL, timeout = TIMEOUT) {
        this.baseUrl = baseUrl;
        this.timeout = timeout;
    }
    
    async get(endpoint) {
        const url = `${this.baseUrl}/${endpoint}`;
        const response = await fetch(url, { 
            headers: { 'Content-Type': 'application/json' },
            signal: AbortSignal.timeout(this.timeout)
        });
        return await response.json();
    }
    
    async post(endpoint, data) {
        const url = `${this.baseUrl}/${endpoint}`;
        const response = await fetch(url, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify(data)
        });
        return await response.json();
    }
}

export default ApiClient;

// utils/validation.js
export function validarEmail(email) {
    const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return regex.test(email);
}

export function validarCpf(cpf) {
    // Lógica simplificada de validação de CPF
    const soNumeros = cpf.replace(/\D/g, '');
    return soNumeros.length === 11;
}

export const validadores = {
    email: validarEmail,
    cpf: validarCpf
};

// utils/string.js
export function formatarMoeda(valor) {
    return new Intl.NumberFormat('pt-BR', {
        style: 'currency',
        currency: 'BRL'
    }).format(valor);
}

export function truncarTexto(texto, limite) {
    if (texto.length <= limite) return texto;
    return texto.substr(0, limite) + '...';
}

// utils/index.js - Barrel Pattern
export { validarEmail, validarCpf, validadores } from './validation.js';
export { formatarMoeda, truncarTexto } from './string.js';

// main.js - utilizando barrel pattern
import { validarEmail, formatarMoeda } from './utils/index.js';
// OU, com barrels, pode-se usar:
// import { validarEmail, formatarMoeda } from './utils'; // Dependendo da configuração

// 5. Recursos avançados de ES Modules
// data-fetcher.js
const CACHE = new Map();

export async function fetchDataComCache(url) {
    if (CACHE.has(url)) {
        console.log('Retornando do cache:', url);
        return CACHE.get(url);
    }
    
    const response = await fetch(url);
    const data = await response.json();
    
    CACHE.set(url, data);
    return data;
}

// constants.js
export const STATUS_CODES = Object.freeze({
    SUCCESS: 200,
    NOT_FOUND: 404,
    SERVER_ERROR: 500
});

export const HTTP_METHODS = Object.freeze([
    'GET',
    'POST',
    'PUT',
    'DELETE',
    'PATCH'
]);

// helpers.js
export function criarEndpoint(rota, params = {}) {
    const queryString = new URLSearchParams(params).toString();
    return queryString ? `${rota}?${queryString}` : rota;
}

export function delay(milliseconds) {
    return new Promise(resolve => setTimeout(resolve, milliseconds));
}

// 1. Exportações no CommonJS
// math-utils.cjs
const E = 2.718;
const PI = 3.14159;

function somar(a, b) {
    return a + b;
}

function subtrair(a, b) {
    return a - b;
}

// Exportação nomeada
exports.E = E;
exports.PI = PI;
exports.somar = somar;
exports.subtrair = subtrair;

// OU exportar tudo de uma vez
// module.exports = {
//     E,
//     PI,
//     somar,
//     subtrair
// };

// OU exportar como exportação padrão
// module.exports = somar;

// 2. Exportação padrão no CommonJS
// calculator.cjs
const { somar, subtrair } = require('./math-utils.cjs');

class Calculator {
    constructor() {
        this.history = [];
    }
    
    add(a, b) {
        const result = somar(a, b);
        this.history.push({ operation: 'add', a, b, result });
        return result;
    }
    
    subtract(a, b) {
        const result = subtrair(a, b);
        this.history.push({ operation: 'subtract', a, b, result });
        return result;
    }
    
    getHistory() {
        return [...this.history];
    }
}

// Exportação padrão no CommonJS
module.exports = Calculator;

// 3. Importações no CommonJS
// app.cjs
const Calculator = require('./calculator.cjs'); // Importação padrão
const { E, PI, somar } = require('./math-utils.cjs'); // Importações nomeadas
const MathUtils = require('./math-utils.cjs'); // Namespace import (todo o objeto)

// Importação dinâmica no CommonJS
const caminhoModulo = './math-utils.cjs';
const moduloDinamico = require(caminhoModulo);

// 4. Recursos avançados do CommonJS
// config.cjs
const API_BASE_URL = process.env.API_BASE_URL || 'https://api.exemplo.com';
const TIMEOUT = parseInt(process.env.TIMEOUT) || 5000;

module.exports = {
    API_BASE_URL,
    TIMEOUT,
    headers: {
        'Content-Type': 'application/json'
    }
};

// api-client.cjs
const config = require('./config.cjs');

class ApiClient {
    constructor(baseUrl = config.API_BASE_URL, timeout = config.TIMEOUT) {
        this.baseUrl = baseUrl;
        this.timeout = timeout;
    }
    
    async get(endpoint) {
        const url = `${this.baseUrl}/${endpoint}`;
        const response = await fetch(url, { 
            headers: config.headers,
            signal: AbortSignal.timeout(this.timeout)
        });
        return await response.json();
    }
    
    async post(endpoint, data) {
        const url = `${this.baseUrl}/${endpoint}`;
        const response = await fetch(url, {
            method: 'POST',
            headers: config.headers,
            body: JSON.stringify(data)
        });
        return await response.json();
    }
}

module.exports = ApiClient;

// utils/validation.cjs
function validarEmail(email) {
    const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return regex.test(email);
}

function validarCpf(cpf) {
    const soNumeros = cpf.replace(/\D/g, '');
    return soNumeros.length === 11;
}

module.exports = {
    validarEmail,
    validarCpf,
    validadores: {
        email: validarEmail,
        cpf: validarCpf
    }
};

// utils/string.cjs
function formatarMoeda(valor) {
    return new Intl.NumberFormat('pt-BR', {
        style: 'currency',
        currency: 'BRL'
    }).format(valor);
}

function truncarTexto(texto, limite) {
    if (texto.length <= limite) return texto;
    return texto.substr(0, limite) + '...';
}

module.exports = {
    formatarMoeda,
    truncarTexto
};

// utils/index.cjs - Barrel Pattern para CommonJS
const validation = require('./validation.cjs');
const string = require('./string.cjs');

module.exports = {
    ...validation,
    ...string
};

// main.cjs - utilizando imports CommonJS
const Calculator = require('./calculator.cjs');
const { validarEmail, formatarMoeda } = require('./utils/index.cjs');

// 5. Diferenças práticas entre ES Modules e CommonJS

// Exemplo de dinamismo que apenas CommonJS permite:
function carregarPlugin(nomePlugin) {
    // Caminho determinado em tempo de execução
    const caminho = `./plugins/${nomePlugin}.cjs`;
    return require(caminho); // Isso é possível no CommonJS mas não em ES Modules estático
}

// Exemplo de wrapper para compatibilidade
function compatibilidadeESM(nomeModulo) {
    // Simula import dinâmico para módulos CommonJS
    return import(`./${nomeModulo}.js`);
}

// Manipulação de __dirname e __filename (específicos do CommonJS)
const path = require('path');
const fs = require('fs');

// Caminhos absolutos relativos ao arquivo atual
const diretorioAtual = __dirname; // Diretório do arquivo atual
const caminhoArquivo = __filename; // Caminho completo do arquivo

// Para ES Modules, equivalentes:
// import { fileURLToPath } from 'url';
// import { dirname } from 'path';
// const __filename = fileURLToPath(import.meta.url);
// const __dirname = dirname(__filename);

// Exportação condicional baseada em ambiente
if (typeof module !== 'undefined' && module.exports) {
    // Ambiente CommonJS
    module.exports = { validarEmail, validarCpf };
} else if (typeof exports !== 'undefined') {
    // Outro ambiente com exports
    exports.validarEmail = validarEmail;
    exports.validarCpf = validarCpf;
} else {
    // Ambiente browser ou outro
    window.Validadores = { validarEmail, validarCpf };
}

// Exemplo de polyfill para importações dinâmicas no CommonJS
async function importarDinamicamenteCJS(caminho) {
    if (typeof require === 'function' && require.resolve) {
        // Verifica se o módulo existe
        try {
            return require(caminho);
        } catch (erro) {
            console.warn(`Módulo ${caminho} não encontrado:`, erro.message);
            return null;
        }
    }
    throw new Error('Ambiente não suporta require');
}

// Sistema de plugins usando CommonJS
class GerenciadorPlugins {
    constructor() {
        this.plugins = new Map();
    }
    
    carregarPlugin(nome) {
        try {
            const Plugin = require(`./plugins/${nome}.cjs`);
            this.plugins.set(nome, new Plugin());
            console.log(`Plugin ${nome} carregado com sucesso`);
        } catch (erro) {
            console.error(`Falha ao carregar plugin ${nome}:`, erro.message);
        }
    }
    
    executarPlugin(nome, ...args) {
        const plugin = this.plugins.get(nome);
        if (plugin && typeof plugin.executar === 'function') {
            return plugin.executar(...args);
        }
        throw new Error(`Plugin ${nome} não encontrado ou não tem método executar`);
    }
}

// Uso do gerenciador de plugins
// const gerenciador = new GerenciadorPlugins();
// gerenciador.carregarPlugin('minha-ferramenta');
// gerenciador.executarPlugin('minha-ferramenta', dados);

// Exemplo de configuração de bundlers (não executável diretamente, mas ilustrativo)

/*
WEBPACK CONFIGURATION EXAMPLE
webpack.config.js
*/
/*
const path = require('path');
const HtmlWebpackPlugin = require('html-webpack-plugin');

module.exports = {
    entry: './src/index.js',
    output: {
        path: path.resolve(__dirname, 'dist'),
        filename: '[name].[contenthash].js',
        clean: true
    },
    module: {
        rules: [
            {
                test: /\.js$/,
                exclude: /node_modules/,
                use: {
                    loader: 'babel-loader',
                    options: {
                        presets: ['@babel/preset-env']
                    }
                }
            },
            {
                test: /\.css$/,
                use: ['style-loader', 'css-loader']
            }
        ]
    },
    plugins: [
        new HtmlWebpackPlugin({
            template: './src/index.html'
        })
    ],
    optimization: {
        splitChunks: {
            chunks: 'all',
            cacheGroups: {
                vendor: {
                    test: /[\\/]node_modules[\\/]/,
                    name: 'vendors',
                    chunks: 'all',
                }
            }
        }
    },
    devServer: {
        static: './dist',
        hot: true
    }
};
*/

/*
ROLLUP CONFIGURATION EXAMPLE
rollup.config.js
*/
/*
import { nodeResolve } from '@rollup/plugin-node-resolve';
import commonjs from '@rollup/plugin-commonjs';
import babel from '@rollup/plugin-babel';

export default {
    input: 'src/main.js',
    output: {
        file: 'dist/bundle.js',
        format: 'iife', // ou 'umd', 'es', 'cjs'
        name: 'MyLibrary',
        sourcemap: true
    },
    plugins: [
        nodeResolve(),
        commonjs(),
        babel({ babelHelpers: 'bundled' })
    ]
};
*/

/*
PARCEL CONFIGURATION EXAMPLE
Nenhuma configuração necessária para uso básico
Mas pode usar .parcelrc para personalização
*/

/*
VITE CONFIGURATION EXAMPLE
vite.config.js
*/
/*
import { defineConfig } from 'vite'
import { resolve } from 'path'

export default defineConfig({
  build: {
    rollupOptions: {
      input: {
        main: resolve(__dirname, 'index.html'),
        nested: resolve(__dirname, 'nested/index.html')
      }
    }
  }
})
*/

// Exemplos práticos de como os bundlers otimizam o código

// 1. Tree Shaking - eliminação de código não utilizado
// math-library.js
export function somar(a, b) {
    return a + b;
}

export function subtrair(a, b) {
    return a - b;
}

export function multiplicar(a, b) {
    return a * b;
}

export function dividir(a, b) {
    if (b === 0) throw new Error('Divisão por zero');
    return a / b;
}

// main.js - só importamos somar, então outras funções podem ser removidas
import { somar } from './math-library.js';

console.log(somar(2, 3)); // Apenas esta função será incluída no bundle

// 2. Code Splitting - divisão de código
// main.js
async function carregarFerramentasAvancadas() {
    // Isto cria um chunk separado que é carregado sob demanda
    const { CalculadoraCientifica } = await import('./calculadora-cientifica.js');
    return new CalculadoraCientifica();
}

// Supondo que calculadora-cientifica.js:
// calculadora-cientifica.js
import { somar, subtrair, multiplicar, dividir } from './math-library.js';

class CalculadoraCientifica {
    constructor() {
        this.historico = [];
    }
    
    potencia(base, expoente) {
        return Math.pow(base, expoente);
    }
    
    raizQuadrada(numero) {
        return Math.sqrt(numero);
    }
}

export { CalculadoraCientifica };

// 3. Dynamic Imports com importação condicional
async function carregarModuloCondicional(usuario) {
    if (usuario.tipo === 'admin') {
        // Carrega funcionalidades administrativas apenas se necessário
        const adminModule = await import('./modulo-admin.js');
        return adminModule;
    } else {
        // Carrega funcionalidades padrão
        const userModule = await import('./modulo-usuario.js');
        return userModule;
    }
}

// 4. Lazy Loading de funcionalidades
class App {
    constructor() {
        this._moduloRelatorio = null;
        this._moduloGraficos = null;
    }
    
    async carregarRelatorios() {
        if (!this._moduloRelatorio) {
            this._moduloRelatorio = await import('./modulos/relatorios.js');
        }
        return this._moduloRelatorio;
    }
    
    async carregarGraficos() {
        if (!this._moduloGraficos) {
            this._moduloGraficos = await import('./modulos/graficos.js');
        }
        return this._moduloGraficos;
    }
}

// 5. Exemplo de plugin para transformação de código
// isto é como um plugin do bundler funcionaria
function pluginTransformacaoCustomizada() {
    return {
        name: 'transformacao-customizada',
        transform(code, id) {
            // Transformar código fonte antes de empacotar
            if (id.endsWith('.js')) {
                // Exemplo: substituir chamadas de console.log em produção
                if (process.env.NODE_ENV === 'production') {
                    code = code.replace(/console\.log\([^)]*\);?/g, '');
                }
            }
            return {
                code,
                map: null // source map se necessário
            };
        }
    };
}

// 6. Exemplo de otimização: Lazy Components (semelhante ao que frameworks fazem)
function criarComponenteLazy(importFuncao, loadingComponente = null) {
    let componenteCarregado = null;
    
    return async function(props) {
        if (!componenteCarregado) {
            if (loadingComponente) {
                // Mostrar componente de loading
                return loadingComponente;
            }
            
            const modulo = await importFuncao();
            componenteCarregado = modulo.default || modulo;
        }
        
        return componenteCarregado(props);
    };
}

// Uso do componente lazy
const ComponenteAdmin = criarComponenteLazy(
    () => import('./componentes/admin-panel.js'),
    () => '<div>Carregando painel administrativo...</div>'
);

// 7. Exemplo de split de código baseado em rotas
class GerenciadorRotas {
    constructor() {
        this.rotas = new Map();
    }
    
    adicionarRota(caminho, carregarModulo) {
        this.rotas.set(caminho, carregarModulo);
    }
    
    async navegarPara(caminho) {
        const carregarModulo = this.rotas.get(caminho);
        
        if (carregarModulo) {
            try {
                const modulo = await carregarModulo();
                // Renderizar componente da rota
                return modulo.renderizar();
            } catch (erro) {
                console.error(`Erro ao carregar rota ${caminho}:`, erro);
                return '<div>Erro ao carregar página</div>';
            }
        } else {
            return '<div>Página não encontrada</div>';
        }
    }
}

// Configuração das rotas com importação dinâmica
const gerenciadorRotas = new GerenciadorRotas();

gerenciadorRotas.adicionarRota('/', () => import('./paginas/home.js'));
gerenciadorRotas.adicionarRota('/sobre', () => import('./paginas/sobre.js'));
gerenciadorRotas.adicionarRota('/contato', () => import('./paginas/contato.js'));
gerenciadorRotas.adicionarRota('/admin', () => import('./paginas/admin.js'));

// O bundler criaria chunks separados para cada uma dessas importações
// permitindo carregamento sob demanda

// 8. Exemplo de externalização de dependências
// Quando você quer que certas bibliotecas não sejam incluídas no bundle
// Ex: jQuery, React, etc., carregados separadamente

// Suponha que React é carregado separadamente
// MeuComponente.js
// (Aqui o bundler entenderia que React é externo e não incluiria no bundle)

// 9. Exemplo prático de como usar importações dinâmicas para otimização
async function otimizarCarregamento() {
    // Carregar recursos apenas quando necessários
    const larguraTela = window.innerWidth;
    
    if (larguraTela > 768) {
        // Apenas carregar funcionalidades para desktop
        const { inicializarDesktop } = await import('./desktop/features.js');
        inicializarDesktop();
    } else {
        // Apenas carregar funcionalidades para mobile
        const { inicializarMobile } = await import('./mobile/features.js');
        inicializarMobile();
    }
    
    // Carregar biblioteca de terceiros apenas quando necessário
    const botaoGrafico = document.querySelector('#botao-grafico');
    botaoGrafico.addEventListener('click', async () => {
        // Carregar biblioteca de gráficos somente quando o botão for clicado
        const Chart = await import('chart.js');
        // Inicializar gráfico
        new Chart.default(/* configuração */);
    });
}

// Exemplo de package.json com configurações avançadas
/*
{
  "name": "projeto-exemplo",
  "version": "1.0.0",
  "description": "Exemplo de configuração de pacote",
  "main": "index.js",
  "type": "module",  // Permite ES Modules no Node.js
  "scripts": {
    "start": "node index.js",
    "dev": "nodemon index.js",
    "build": "webpack --mode production",
    "test": "jest",
    "lint": "eslint src/",
    "pre-commit": "lint-staged",
    "analyze": "webpack-bundle-analyzer dist/stats.json"
  },
  "dependencies": {
    "express": "^4.18.0",
    "lodash": "^4.17.21",
    "axios": "^1.3.0"
  },
  "devDependencies": {
    "jest": "^29.0.0",
    "webpack": "^5.74.0",
    "eslint": "^8.20.0",
    "nodemon": "^2.0.20"
  },
  "engines": {
    "node": ">=16.0.0",
    "npm": ">=8.0.0"
  },
  "volta": {
    "node": "18.12.1"
  },
  "keywords": ["javascript", "modules", "bundler"],
  "author": "Desenvolvedor Exemplo",
  "license": "MIT"
}
*/

// 1. Gerenciamento de versões e lock files
// O arquivo package-lock.json (npm), yarn.lock (yarn), ou pnpm-lock.yaml (pnpm)
// garante que as mesmas versões de dependências sejam instaladas em todos os ambientes

// Semver (Semantic Versioning): MAJOR.MINOR.PATCH
// ^1.2.3 -> permite atualizações de MINOR e PATCH (1.x.x)
// ~1.2.3 -> permite apenas atualizações de PATCH (1.2.x)
// 1.2.3 -> versão exata

// 2. Scripts e hooks
// Exemplos de scripts úteis em package.json

// "scripts": {
//   "prebuild": "npm run clean",
//   "build": "webpack --mode production",
//   "postbuild": "npm run analyze",
//   "prepublishOnly": "npm test && npm run build",
//   "prepare": "husky install", // Para Git hooks
//   "format": "prettier --write .",
//   "check-format": "prettier --check .",
//   "security-audit": "npm audit --audit-level high"
// }

// 3. Workspaces para monorepos
// Exemplo de configuração de workspaces em package.json
/*
{
  "name": "empresa-monorepo",
  "private": true,
  "workspaces": [
    "packages/*",
    "apps/*"
  ],
  "scripts": {
    "build:all": "lerna run build",
    "test:all": "lerna run test"
  }
}
*/

// 4. Exemplo prático de gerenciamento de dependências
class GerenciadorDependencias {
    constructor(projetoPath) {
        this.projetoPath = projetoPath;
        this.packageJson = this.lerPackageJson();
        this.instalador = this.detectarInstalador();
    }
    
    lerPackageJson() {
        // Em ambiente real, ler o arquivo package.json
        return {
            dependencies: {},
            devDependencies: {},
            peerDependencies: {}
        };
    }
    
    detectarInstalador() {
        // Verificar qual instalador está disponível
        // Checar por yarn.lock, pnpm-lock.yaml ou package-lock.json
        return 'npm'; // Exemplo
    }
    
    async instalarPacote(nome, versao = 'latest', tipo = 'dependencies') {
        const comando = this.gerarComandoInstall(nome, versao, tipo);
        console.log(`Executando: ${comando}`);
        
        // Em implementação real, executar o comando de instalação
        // return exec(comando);
    }
    
    gerarComandoInstall(nome, versao, tipo) {
        const prefixo = this.instalador;
        
        if (tipo === 'devDependencies') {
            if (prefixo === 'npm') return `npm install --save-dev ${nome}@${versao}`;
            if (prefixo === 'yarn') return `yarn add --dev ${nome}@${versao}`;
            if (prefixo === 'pnpm') return `pnpm add --save-dev ${nome}@${versao}`;
        } else if (tipo === 'peerDependencies') {
            // Peer deps são geralmente especificadas manualmente
            console.warn('Peer dependencies geralmente são especificadas manualmente em package.json');
        }
        
        // Dependências normais
        if (prefixo === 'npm') return `npm install --save ${nome}@${versao}`;
        if (prefixo === 'yarn') return `yarn add ${nome}@${versao}`;
        if (prefixo === 'pnpm') return `pnpm add ${nome}@${versao}`;
    }
    
    async atualizarPacotes() {
        // Atualizar todas as dependências
        const comando = this.instalador === 'npm' ? 'npm update' :
                         this.instalador === 'yarn' ? 'yarn upgrade' :
                         'pnpm update';
        
        console.log(`Executando atualização: ${comando}`);
    }
    
    async checarSeguranca() {
        // Checar vulnerabilidades
        const comando = this.instalador === 'npm' ? 'npm audit' :
                         this.instalador === 'yarn' ? 'yarn audit' :
                         'pnpm audit';
        
        console.log(`Checando segurança: ${comando}`);
    }
    
    async desinstalarPacote(nome) {
        const comando = this.instalador === 'npm' ? `npm uninstall ${nome}` :
                         this.instalador === 'yarn' ? `yarn remove ${nome}` :
                         `pnpm remove ${nome}`;
        
        console.log(`Desinstalando pacote: ${comando}`);
    }
}

// 5. Exemplo de scripts para otimização de dependências

// Script para detectar pacotes duplicados
function detectarPacotesDuplicados() {
    // Em implementação real, analisaria o node_modules ou lock file
    console.log('Verificando pacotes duplicados...');
    // Ex: npm ls --depth=0 | grep -E "\\w+@\\w+" para ver pacotes instalados
}

// Script para auditoria de licenças
function auditarLicencas() {
    // Verificar licenças das dependências
    console.log('Auditando licenças das dependências...');
    // Ex: license-checker ou ferramentas similares
}

// Script para atualização segura
async function atualizarDependenciasSensiveis() {
    // Identificar e atualizar dependências críticas com segurança
    console.log('Atualizando dependências críticas...');
    
    // Verificar se há atualizações de segurança
    // npm audit --json | jq '.actions[] | select(.action === "update")'
    
    // Atualizar apenas dependências com issues de segurança
    // npm audit fix --dry-run (primeiro verificar)
    // npm audit fix (aplicar alterações)
}

// 6. Estratégias avançadas de gerenciamento

// Exemplo de política de dependências
const politicaDependencias = {
    // Política de versões
    politicaVersoes: {
        minimas: {
            node: '>=16.0.0',
            express: '>=4.18.0'
        },
        recomendadas: {
            react: '^18.0.0',
            webpack: '~5.70.0'
        }
    },
    
    // Política de segurança
    politicaSeguranca: {
        nivelAceitavel: 'moderate', // low, moderate, high, critical
        auditoriaAutomatica: true,
        atualizacaoAutomatica: ['eslint', 'prettier'] // Apenas ferramentas de desenvolvimento
    },
    
    // Política de tamanho
    politicaTamanho: {
        tamanhoMaximoDependencias: '100MB',
        evitarDependencias: ['moment'] // Por tamanho/substituição
    }
};

// 7. Ferramentas e práticas recomendadas

// Exemplo de script de pré-commit para verificar dependências
function scriptPreCommit() {
    // Verificar se todos os testes passam
    // Verificar se não há vulnerabilidades
    // Verificar formatação e lint
    
    console.log('Rodando verificações de pré-commit...');
    
    const verificacoes = [
        {
            nome: 'Testes',
            script: 'npm test',
            obrigatorio: true
        },
        {
            nome: 'Vulnerabilidades',
            script: 'npm audit --audit-level moderate',
            obrigatorio: true
        },
        {
            nome: 'Lint',
            script: 'npm run lint',
            obrigatoria: true
        }
    ];
    
    return verificacoes;
}

// 8. Diferenças entre os gerenciadores

/*
NPM:
- Mais antigo e mais usado
- Instala dependências em node_modules (flat structure a partir do v3)
- Usa package-lock.json
- Mais lento que yarn e pnpm
- Melhor integração com o ecossistema Node.js

YARN:
- Mais rápido que npm (inicialmente)
- Usa yarn.lock
- Tem recursos como workspaces melhores
- Pioneiro em deterministic installs
- Menor uso agora com melhoria do npm

PNPM:
- Mais eficiente em uso de disco (hard links)
- Usa pnpm-lock.yaml
- Muito rápido
- Usa um content-addressable store
- Menor consumo de espaço em disco
*/

// Exemplo de como escolher o gerenciador apropriado

function escolherGerenciador(projetoTipo, restricoes) {
    const opcoes = {
        npm: {
            pontosForte: ['ecossistema', 'estabilidade', 'documentacao'],
            pontosFraco: ['velocidade', 'espaco_disco'],
            recomendadoPara: ['projetos_padrao', 'iniciantes', 'integracao_ci_cd']
        },
        yarn: {
            pontosForte: ['velocidade', 'workspaces', 'seguranca'],
            pontosFraco: ['complexidade', 'menor_atualizacao'],
            recomendadoPara: ['monorepos', 'projetos_complexos']
        },
        pnpm: {
            pontosForte: ['eficiencia_disco', 'velocidade', 'escala'],
            pontosFraco: ['curva_aprendizado', 'compatibilidade'],
            recomendadoPara: ['monorepos_grandes', 'multi_projetos']
        }
    };
    
    // Lógica de escolha baseada nos critérios
    if (restricoes.espaco_disco_limitado) return 'pnpm';
    if (restricoes.monorepo_grande) return 'pnpm';
    if (projetoTipo === 'nova_empresa') return 'npm';
    if (projetoTipo === 'monorepo') return 'yarn';
    
    return 'npm'; // Padrão
}

// 9. Melhores práticas
const melhoresPraticas = [
    "Usar lock files (package-lock.json, yarn.lock, etc.)",
    "Especificar versões exatas para dependências críticas",
    "Atualizar regularmente dependências com segurança",
    "Usar dependências de desenvolvimento apropriadamente",
    "Evitar dependências desnecessárias (dependency bloat)",
    "Auditar regularmente vulnerabilidades",
    "Documentar dependências críticas e suas razões",
    "Usar scopes para pacotes privados (@minhaempresa/pacote)"
];

console.log('Melhores práticas:', melhoresPraticas);

// 10. Exemplo de configuração para CI/CD
const configuracaoCI = {
    cache: {
        chave: 'node_modules-${{ hashFiles(\'**/package-lock.json\') }}',
        caminho: './node_modules'
    },
    comandos: [
        'npm ci', // Instala exatamente como especificado no lock file
        'npm run build',
        'npm run test',
        'npm run security-audit'
    ]
};