/**
 * Copyright (c) 2024-2025 Тарабанов Александр Викторович
 * All rights reserved.
 * 
 * This software is proprietary and confidential.
 * Unauthorized copying, modification, or distribution is prohibited.
 * 
 * For licensing inquiries: info@hb3-accelerator.com
 * Website: https://hb3-accelerator.com
 * GitHub: https://github.com/HB3-ACCELERATOR
 */

const express = require('express');
const router = express.Router();
const { ethers } = require('ethers');
const { Interface, AbiCoder } = ethers;
const hre = require('hardhat');
const rpcProviderService = require('../services/rpcProviderService');
const { spawn } = require('child_process');
const path = require('path');
const { MODULE_TYPE_TO_ID, MODULE_NAMES, MODULE_DESCRIPTIONS } = require('../constants/moduleIds');

// Утилитарная функция для автоматической компиляции контрактов
async function autoCompileContracts() {
  console.log(`[DLE Modules] Запуск автоматической компиляции контрактов...`);
  
  return new Promise((resolve, reject) => {
    const compileProcess = spawn('npx', ['hardhat', 'compile'], {
      cwd: path.join(__dirname, '..'),
      stdio: 'pipe'
    });

    let stdout = '';
    let stderr = '';

    compileProcess.stdout.on('data', (data) => {
      stdout += data.toString();
    });

    compileProcess.stderr.on('data', (data) => {
      stderr += data.toString();
    });

    compileProcess.on('close', (code) => {
      if (code === 0) {
        console.log(`[DLE Modules] ✅ Компиляция завершена успешно`);
        resolve();
      } else {
        console.error(`[DLE Modules] ❌ Ошибка компиляции:`, stderr);
        reject(new Error(`Ошибка компиляции: ${stderr}`));
      }
    });

    compileProcess.on('error', (error) => {
      console.error(`[DLE Modules] ❌ Ошибка запуска компиляции:`, error);
      reject(error);
    });
  });
}

// Универсальная функция для выполнения операций с повторами
async function executeWithRetries(operation, operationName, maxRetries = 1, retryDelay = 30000) {
  let lastError = null;
  
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      console.log(`[Retry Logic] ${operationName} - попытка ${attempt}/${maxRetries}`);
      const result = await operation();
      console.log(`[Retry Logic] ${operationName} - успешно выполнено с попытки ${attempt}`);
      return result;
    } catch (error) {
      lastError = error;
      console.error(`[Retry Logic] ${operationName} - ошибка на попытке ${attempt}:`, error.message);
      
      if (attempt < maxRetries) {
        console.log(`[Retry Logic] ${operationName} - повтор через ${retryDelay}ms...`);
        await new Promise(resolve => setTimeout(resolve, retryDelay));
      }
    }
  }
  
  console.error(`[Retry Logic] ${operationName} - все попытки исчерпаны`);
  throw lastError;
}

// Функция для выполнения операций с повторами для каждой сети
async function executeForEachNetwork(networks, operation, operationName, maxRetries = 1, retryDelay = 30000) {
  const results = [];
  let allSuccessful = true;

  for (const network of networks) {
    try {
      const result = await executeWithRetries(
        () => operation(network),
        `${operationName} в сети ${network.networkName} (${network.chainId})`,
        maxRetries,
        retryDelay
      );
      results.push(result);
    } catch (error) {
      console.error(`[Retry Logic] Ошибка ${operationName} в сети ${network.chainId}:`, error.message);
      results.push({
        chainId: network.chainId,
        networkName: network.networkName,
        status: 'error',
        message: error.message,
        attempts: maxRetries
      });
      allSuccessful = false;
    }
  }

  return { results, allSuccessful };
}

// Проверить активность модуля
router.post('/is-module-active', async (req, res) => {
  try {
    const { dleAddress, moduleId, chainId } = req.body;
    
    if (!dleAddress || !moduleId) {
      return res.status(400).json({
        success: false,
        error: 'Адрес DLE и ID модуля обязательны'
      });
    }

    // Если chainId не указан, используем первый доступный
    let targetChainId = chainId;
    if (!targetChainId) {
      const allProviders = await rpcProviderService.getAllRpcProviders();
      if (allProviders.length === 0) {
        return res.status(500).json({
          success: false,
          error: 'RPC провайдеры не найдены в базе данных'
        });
      }
      targetChainId = allProviders[0].chain_id;
    }

    console.log(`[DLE Modules] Проверка активности модуля: ${moduleId} для DLE: ${dleAddress} в сети ${targetChainId}`);

    const rpcUrl = await rpcProviderService.getRpcUrlByChainId(targetChainId);
    if (!rpcUrl) {
      return res.status(500).json({
        success: false,
        error: `RPC URL для сети ${targetChainId} не найден`
      });
    }

    const provider = new ethers.JsonRpcProvider(rpcUrl);
    
    const dleAbi = [
      "function isModuleActive(bytes32 _moduleId) external view returns (bool)"
    ];

    const dle = new ethers.Contract(dleAddress, dleAbi, provider);

    // Проверяем активность модуля
    const isActive = await dle.isModuleActive(moduleId);

    console.log(`[DLE Modules] Активность модуля ${moduleId}: ${isActive}`);

    res.json({
      success: true,
      data: {
        isActive: isActive
      }
    });

  } catch (error) {
    console.error('[DLE Modules] Ошибка при проверке активности модуля:', error);
    res.status(500).json({
      success: false,
      error: 'Ошибка при проверке активности модуля: ' + error.message
    });
  }
});

// Получить информацию о задеплоенных модулях для DLE
router.get('/deployed/:dleAddress', async (req, res) => {
  try {
    const { dleAddress } = req.params;
    
    if (!dleAddress) {
      return res.status(400).json({
        success: false,
        error: 'Адрес DLE обязателен'
      });
    }

    console.log(`[DLE Modules] Получение информации о модулях для DLE: ${dleAddress}`);

    // Получаем информацию о модулях из файлов деплоя
    const modulesInfo = await getDeployedModulesInfo(dleAddress);

    res.json({
      success: true,
      data: modulesInfo
    });

  } catch (error) {
    console.error('[DLE Modules] Ошибка при получении информации о модулях:', error);
    res.status(500).json({
      success: false,
      error: 'Ошибка при получении информации о модулях: ' + error.message
    });
  }
});

// Получить адрес модуля
router.post('/get-module-address', async (req, res) => {
  try {
    const { dleAddress, moduleId, chainId } = req.body;
    
    if (!dleAddress || !moduleId) {
      return res.status(400).json({
        success: false,
        error: 'Адрес DLE и ID модуля обязательны'
      });
    }

    const targetChainId = Number(chainId) || 11155111;
    console.log(`[DLE Modules] Получение адреса модуля: ${moduleId} для DLE: ${dleAddress} в сети: ${targetChainId}`);

    const rpcUrl = await rpcProviderService.getRpcUrlByChainId(targetChainId);
    if (!rpcUrl) {
      return res.status(500).json({
        success: false,
        error: `RPC URL для сети ${targetChainId} не найден`
      });
    }

    const provider = new ethers.JsonRpcProvider(rpcUrl);
    
    const dleAbi = [
      "function getModuleAddress(bytes32 _moduleId) external view returns (address)"
    ];

    const dle = new ethers.Contract(dleAddress, dleAbi, provider);

    // Получаем адрес модуля
    const moduleAddress = await dle.getModuleAddress(moduleId);

    console.log(`[DLE Modules] Адрес модуля ${moduleId} (chainId ${targetChainId}): ${moduleAddress}`);

    res.json({
      success: true,
      data: {
        moduleAddress: moduleAddress,
        chainId: targetChainId
      }
    });

  } catch (error) {
    console.error('[DLE Modules] Ошибка при получении адреса модуля:', error);
    res.status(500).json({
      success: false,
      error: 'Ошибка при получении адреса модуля: ' + error.message
    });
  }
});

// Подготовить транзакции инициализации модулей для подписи в кошельке (во всех сетях)
router.post('/prepare-initialize-modules-all-networks', async (req, res) => {
  try {
    const { dleAddress } = req.body;
    if (!dleAddress) {
      return res.status(400).json({ success: false, error: 'Адрес DLE обязателен' });
    }

    // Получаем поддерживаемые сети из контракта
    const supportedNetworks = await getSupportedNetworksFromDLE(dleAddress);
    if (supportedNetworks.length === 0) {
      return res.status(400).json({ success: false, error: 'Не найдены поддерживаемые сети для DLE' });
    }

    // Модули инициализируются только через governance предложения

    // Module IDs - используем константы
    const moduleIds = MODULE_TYPE_TO_ID;

    const results = [];
    for (const network of supportedNetworks) {
      try {
        const provider = new ethers.JsonRpcProvider(network.rpcUrl);
        const dle = new ethers.Contract(
          dleAddress,
          [
            'function getModuleAddress(bytes32 _moduleId) external view returns (address)',
          ],
          provider
        );

        // Модули теперь инициализируются только через governance
        const already = false;
        const treasuryAddress = await dle.getModuleAddress(moduleIds.treasury);
        const timelockAddress = await dle.getModuleAddress(moduleIds.timelock);
        const readerAddress = await dle.getModuleAddress(moduleIds.reader);

        if (
          treasuryAddress === '0x0000000000000000000000000000000000000000' ||
          timelockAddress === '0x0000000000000000000000000000000000000000' ||
          readerAddress === '0x0000000000000000000000000000000000000000'
        ) {
          results.push({
            chainId: network.chainId,
            networkName: network.networkName,
            status: 'modules_not_deployed',
            message: 'Не все модули задеплоены'
          });
          continue;
        }

        // Модули инициализируются через governance предложения, а не напрямую
        const data = null;

        results.push({
          chainId: network.chainId,
          networkName: network.networkName,
          status: already ? 'already_initialized' : 'ready',
          to: dleAddress,
          data
        });
      } catch (e) {
        results.push({
          chainId: network.chainId,
          networkName: network.networkName,
          status: 'error',
          message: e.message
        });
      }
    }

    return res.json({ success: true, data: { results } });
  } catch (error) {
    console.error('[DLE Modules] Ошибка подготовки инициализации:', error);
    res.status(500).json({ success: false, error: 'Ошибка подготовки инициализации: ' + error.message });
  }
});

// Подготовить транзакции деплоя модуля для подписи в кошельке (во всех сетях)
router.post('/prepare-deploy-module-all-networks', async (req, res) => {
  try {
    const { dleAddress, moduleType, deployerAddress } = req.body;
    if (!dleAddress || !moduleType || !deployerAddress) {
      return res.status(400).json({ success: false, error: 'dleAddress, moduleType и deployerAddress обязательны' });
    }

    // Компиляция на случай отсутствия артефактов
    try { await autoCompileContracts(); } catch (_) {}

    // Получаем поддерживаемые сети
    const supportedNetworks = await getSupportedNetworksFromDLE(dleAddress);
    if (supportedNetworks.length === 0) {
      return res.status(400).json({ success: false, error: 'Не найдены поддерживаемые сети для DLE' });
    }

    // Определяем контракт и аргументы конструктора
    const moduleConfigs = {
      treasury: {
        contractName: 'TreasuryModule',
        args: (chainId) => [dleAddress, chainId, deployerAddress]
      },
      timelock: {
        contractName: 'TimelockModule',
        args: () => [dleAddress]
      },
      reader: {
        contractName: 'DLEReader',
        args: () => [dleAddress]
      }
    };
    const cfg = moduleConfigs[moduleType];
    if (!cfg) return res.status(400).json({ success: false, error: `Неизвестный тип модуля: ${moduleType}` });

    // Загрузка артефакта
    const path = require('path');
    const fs = require('fs');
    const artifactPath = path.join(
      __dirname,
      `../artifacts/contracts/${cfg.contractName}.sol/${cfg.contractName}.json`
    );
    if (!fs.existsSync(artifactPath)) {
      return res.status(500).json({ success: false, error: `Артефакт не найден: ${artifactPath}` });
    }
    const artifact = JSON.parse(fs.readFileSync(artifactPath, 'utf8'));
    const bytecode = artifact.bytecode; // 0x...

    if (!bytecode || bytecode === '0x') {
      return res.status(500).json({ success: false, error: `Пустой bytecode у ${cfg.contractName}` });
    }

    const results = [];
    for (const network of supportedNetworks) {
      try {
        const constructorArgs = cfg.args(network.chainId);
        // Кодируем аргументы конструктора по ABI контракта
        const ctorTypes = (artifact.abi.find(i => i.type === 'constructor')?.inputs || []).map(i => i.type);
        const encodedArgs = ctorTypes.length
          ? AbiCoder.defaultAbiCoder().encode(ctorTypes, constructorArgs)
          : '0x';
        const data = bytecode + (encodedArgs.startsWith('0x') ? encodedArgs.slice(2) : encodedArgs);

        results.push({
          chainId: network.chainId,
          networkName: network.networkName,
          status: 'ready',
          to: null,
          data,
          value: '0x0',
          contractName: cfg.contractName
        });
      } catch (e) {
        results.push({
          chainId: network.chainId,
          networkName: network.networkName,
          status: 'error',
          message: e.message
        });
      }
    }

    return res.json({ success: true, data: { results } });
  } catch (error) {
    console.error('[DLE Modules] Ошибка подготовки деплоя модуля:', error);
    res.status(500).json({ success: false, error: 'Ошибка подготовки деплоя модуля: ' + error.message });
  }
});

// Получить все модули
router.post('/get-all-modules', async (req, res) => {
  try {
    const { dleAddress } = req.body;
    
    if (!dleAddress) {
      return res.status(400).json({
        success: false,
        error: 'Адрес DLE обязателен'
      });
    }

    console.log(`[DLE Modules] Получение всех модулей для DLE: ${dleAddress} (только из блокчейна)`);

    // Получаем информацию о поддерживаемых сетях из DLE контракта
    const supportedNetworks = await getSupportedNetworksFromDLE(dleAddress);
    console.log(`[DLE Modules] Найдено поддерживаемых сетей: ${supportedNetworks.length}`);

    if (supportedNetworks.length === 0) {
      return res.json({
        success: true,
        data: {
          modules: [],
          requiresGovernance: true,
          totalModules: 0,
          activeModules: 0,
          supportedNetworks: []
        }
      });
    }

    // Группируем модули по типам
    const moduleGroups = {
      treasury: {
        moduleId: "0x7472656173757279000000000000000000000000000000000000000000000000", // 32 байта
        moduleName: "TREASURY",
        moduleDescription: "Казначейство DLE - управление финансами, депозиты, выводы, дивиденды",
        addresses: [],
        isActive: true,
        deployedAt: new Date().toISOString()
      },
      timelock: {
        moduleId: "0x74696d656c6f636b000000000000000000000000000000000000000000000000", // 32 байта
        moduleName: "TIMELOCK",
        moduleDescription: "Модуль задержек исполнения - безопасность критических операций через таймлоки",
        addresses: [],
        isActive: true,
        deployedAt: new Date().toISOString()
      },
      reader: {
        moduleId: "0x7265616465720000000000000000000000000000000000000000000000000000", // 32 байта
        moduleName: "READER",
        moduleDescription: "Модуль чтения данных DLE - получение информации о контракте",
        addresses: [],
        isActive: true,
        deployedAt: new Date().toISOString()
      }
    };

    // Проверяем модули в каждой поддерживаемой сети
    for (const network of supportedNetworks) {
      console.log(`[DLE Modules] Проверяем модули в сети: ${network.networkName} (${network.chainId})`);
      
      try {
        const provider = new ethers.JsonRpcProvider(network.rpcUrl);
    
    const dleAbi = [
      "function isModuleActive(bytes32 _moduleId) external view returns (bool)",
          "function getModuleAddress(bytes32 _moduleId) external view returns (address)",
    ];

    const dle = new ethers.Contract(dleAddress, dleAbi, provider);

        // Проверяем инициализацию модулей
        // Модули инициализируются только через governance
        console.log(`[DLE Modules] Модули инициализируются через governance предложения в сети ${network.chainId}`);

        // Проверяем каждый тип модуля
        for (const [moduleType, moduleInfo] of Object.entries(moduleGroups)) {
          try {
            console.log(`[DLE Modules] Проверяем модуль ${moduleInfo.moduleName} (${moduleInfo.moduleId}) в сети ${network.networkName}`);
            const isActive = await dle.isModuleActive(moduleInfo.moduleId);
            console.log(`[DLE Modules] Модуль ${moduleInfo.moduleName} активен: ${isActive}`);
        if (isActive) {
              const moduleAddress = await dle.getModuleAddress(moduleInfo.moduleId);
              
              // Проверяем, не добавлен ли уже этот адрес для этого типа модуля
              const existingAddress = moduleInfo.addresses.find(addr => 
                addr.address.toLowerCase() === moduleAddress.toLowerCase()
              );
              
              if (!existingAddress) {
                moduleInfo.addresses.push({
                  address: moduleAddress,
                  networkName: network.networkName,
                  networkIndex: supportedNetworks.indexOf(network),
                  chainId: Number(network.chainId), // Конвертируем BigInt в Number
                  verificationStatus: 'pending' // По умолчанию pending, можно проверить через Etherscan API
                });
                
                console.log(`[DLE Modules] Найден модуль ${moduleInfo.moduleName} в сети ${network.networkName}: ${moduleAddress}`);
              }
        }
      } catch (error) {
            console.log(`[DLE Modules] Ошибка при проверке модуля ${moduleInfo.moduleName} в сети ${network.chainId}:`, error.message);
          }
        }
      } catch (error) {
        console.log(`[DLE Modules] Ошибка при подключении к сети ${network.chainId}:`, error.message);
      }
    }

    // Преобразуем в массив модулей
    const formattedModules = Object.values(moduleGroups).filter(module => module.addresses.length > 0);
    
    console.log(`[DLE Modules] Найдено типов модулей: ${formattedModules.length}`);

    res.json({
      success: true,
      data: {
        modules: formattedModules,
        requiresGovernance: true,
        totalModules: formattedModules.length,
        activeModules: formattedModules.length,
        supportedNetworks: supportedNetworks
      }
    });

  } catch (error) {
    console.error('[DLE Modules] Ошибка при получении всех модулей:', error);
    res.status(500).json({
      success: false,
      error: 'Ошибка при получении всех модулей: ' + error.message
    });
  }
});

// Создать предложение о добавлении модуля
router.post('/create-add-module-proposal', async (req, res) => {
  try {
    const { dleAddress, description, duration, moduleId, moduleAddress, chainId } = req.body;
    
    if (!dleAddress || !description || !duration || !moduleId || !moduleAddress || !chainId) {
      return res.status(400).json({
        success: false,
        error: 'Все поля обязательны'
      });
    }

    console.log(`[DLE Modules] Создание предложения о добавлении модуля: ${moduleId} для DLE: ${dleAddress}`);

    const rpcUrl = await rpcProviderService.getRpcUrlByChainId(chainId);
    if (!rpcUrl) {
      return res.status(500).json({
        success: false,
        error: `RPC URL для сети ${chainId} не найден`
      });
    }

    const provider = new ethers.JsonRpcProvider(rpcUrl);
    
    const dleAbi = [
      "function createAddModuleProposal(string memory _description, uint256 _duration, bytes32 _moduleId, address _moduleAddress, uint256 _chainId) external returns (uint256)"
    ];

    const dle = new ethers.Contract(dleAddress, dleAbi, provider);

    // Подготавливаем данные для транзакции (не отправляем)
    const txData = await dle.createAddModuleProposal.populateTransaction(
      description, 
      duration, 
      moduleId, 
      moduleAddress, 
      chainId
    );

    console.log(`[DLE Modules] Данные транзакции подготовлены:`, txData);

    res.json({
      success: true,
      data: {
        to: dleAddress,
        data: txData.data,
        value: "0x0",
        gasLimit: "0x1e8480", // 2,000,000 gas
        message: "Подготовлены данные для создания предложения о добавлении модуля. Отправьте транзакцию через MetaMask."
      }
    });

  } catch (error) {
    console.error('[DLE Modules] Ошибка при создании предложения о добавлении модуля:', error);
    res.status(500).json({
      success: false,
      error: 'Ошибка при создании предложения о добавлении модуля: ' + error.message
    });
  }
});

// Создать предложение об удалении модуля
router.post('/create-remove-module-proposal', async (req, res) => {
  try {
    const { dleAddress, description, duration, moduleId, chainId } = req.body;
    
    if (!dleAddress || !description || !duration || !moduleId || !chainId) {
      return res.status(400).json({
        success: false,
        error: 'Все поля обязательны'
      });
    }

    console.log(`[DLE Modules] Создание предложения об удалении модуля: ${moduleId} для DLE: ${dleAddress}`);

    const rpcUrl = await rpcProviderService.getRpcUrlByChainId(11155111);
    if (!rpcUrl) {
      return res.status(500).json({
        success: false,
        error: 'RPC URL для Sepolia не найден'
      });
    }

    const provider = new ethers.JsonRpcProvider(rpcUrl);
    
    const dleAbi = [
      "function createRemoveModuleProposal(string memory _description, uint256 _duration, bytes32 _moduleId, uint256 _chainId) external returns (uint256)"
    ];

    const dle = new ethers.Contract(dleAddress, dleAbi, provider);

    // Создаем предложение
    const tx = await dle.createRemoveModuleProposal(description, duration, moduleId, chainId);
    const receipt = await tx.wait();

    console.log(`[DLE Modules] Предложение об удалении модуля создано:`, receipt);

    res.json({
      success: true,
      data: {
        proposalId: receipt.logs[0].args.proposalId,
        transactionHash: receipt.hash
      }
    });

  } catch (error) {
    console.error('[DLE Modules] Ошибка при создании предложения об удалении модуля:', error);
    res.status(500).json({
      success: false,
      error: 'Ошибка при создании предложения об удалении модуля: ' + error.message
    });
  }
});

// Функция для получения поддерживаемых сетей из DLE контракта
async function getSupportedNetworksFromDLE(dleAddress) {
  try {
    // Получаем все доступные RPC провайдеры из базы данных
    const allRpcProviders = await rpcProviderService.getAllRpcProviders();
    console.log(`[DLE Modules] Найдено RPC провайдеров в базе данных: ${allRpcProviders.length}`);

    if (allRpcProviders.length === 0) {
      console.log(`[DLE Modules] RPC провайдеры не найдены в базе данных`);
      return [];
    }

    // Пробуем подключиться к каждой сети, чтобы найти DLE контракт
    const supportedNetworks = [];
    
    for (const rpcProvider of allRpcProviders) {
      try {
        console.log(`[DLE Modules] Проверяем сеть: ${rpcProvider.network_name} (${rpcProvider.chain_id})`);
        
        const provider = new ethers.JsonRpcProvider(rpcProvider.rpc_url);
        
        const dleAbi = [
          "function getSupportedChainCount() external view returns (uint256)",
          "function getSupportedChainId(uint256 _index) external view returns (uint256)"
        ];

        const dle = new ethers.Contract(dleAddress, dleAbi, provider);

        // Проверяем, существует ли контракт в этой сети
        const code = await provider.getCode(dleAddress);
        if (code === '0x') {
          console.log(`[DLE Modules] DLE контракт не найден в сети ${rpcProvider.chain_id}`);
          continue;
        }

        // Получаем количество поддерживаемых сетей с проверкой
        let chainCount;
        try {
          chainCount = await dle.getSupportedChainCount();
          console.log(`[DLE Modules] DLE в сети ${rpcProvider.chain_id} поддерживает ${chainCount} сетей`);
        } catch (error) {
          console.log(`[DLE Modules] Ошибка получения chainCount в сети ${rpcProvider.chain_id}: ${error.message}`);
          // Если функция не работает, проверяем, что контракт инициализирован
          try {
            // Проверяем что контракт развернут (код не пустой)
            const code = await provider.getCode(dleAddress);
            if (code === '0x' || code.length <= 2) {
              throw new Error('Контракт не развернут');
            }
            console.log(`[DLE Modules] Контракт инициализирован, но getSupportedChainCount() не работает`);
            // Если контракт инициализирован, но getSupportedChainCount() падает,
            // это означает, что supportedChainIds пустой - используем 0
            chainCount = 0;
            console.log(`[DLE Modules] supportedChainIds пустой, используем chainCount = 0`);
          } catch (initError) {
            console.log(`[DLE Modules] Контракт не инициализирован: ${initError.message}`);
            // Пропускаем эту сеть
            continue;
          }
        }

        // Получаем chainId для каждой поддерживаемой сети
        for (let i = 0; i < chainCount; i++) {
          try {
            const chainId = await dle.getSupportedChainId(i);
            
            // Получаем RPC URL для этой сети из базы данных
            const networkRpcUrl = await rpcProviderService.getRpcUrlByChainId(chainId);
            
            if (networkRpcUrl) {
              const networkName = getNetworkNameByChainId(chainId);
              
              // Проверяем, не добавлена ли уже эта сеть
              const existingNetwork = supportedNetworks.find(n => n.chainId === chainId);
              if (!existingNetwork) {
                const etherscanUrl = getEtherscanUrlByChainId(chainId);
                
                supportedNetworks.push({
                  chainId: Number(chainId), // Конвертируем BigInt в Number
                  networkName: networkName,
                  rpcUrl: networkRpcUrl,
                  etherscanUrl: etherscanUrl,
                  networkIndex: i
                });
                
                console.log(`[DLE Modules] Найдена поддерживаемая сеть: ${networkName} (${chainId})`);
              }
            } else {
              console.log(`[DLE Modules] RPC URL не найден для сети ${chainId}`);
            }
          } catch (error) {
            console.log(`[DLE Modules] Ошибка при получении chainId для индекса ${i}:`, error.message);
          }
        }

        // Если нашли поддерживаемые сети, можем остановиться
        if (supportedNetworks.length > 0) {
          break;
        }
        
      } catch (error) {
        console.log(`[DLE Modules] Ошибка при подключении к сети ${rpcProvider.chain_id}:`, error.message);
      }
    }

    return supportedNetworks;
  } catch (error) {
    console.error('[DLE Modules] Ошибка при получении поддерживаемых сетей:', error);
    return [];
  }
}

// Функция для определения названия сети по chainId
function getNetworkNameByChainId(chainId) {
  const networkNames = {
    1: 'Ethereum Mainnet',
    5: 'Goerli',
    11155111: 'Sepolia',
    137: 'Polygon Mainnet',
    80001: 'Mumbai',
    56: 'BSC Mainnet',
    97: 'BSC Testnet',
    42161: 'Arbitrum One',
    421614: 'Arbitrum Sepolia',
    10: 'Optimism',
    11155420: 'Optimism Sepolia',
    8453: 'Base',
    84532: 'Base Sepolia',
    17000: 'Holesky'
  };
  
  return networkNames[chainId] || `Chain ID ${chainId}`;
}

// Функция для определения Etherscan URL по chainId
function getEtherscanUrlByChainId(chainId) {
  const etherscanUrls = {
    1: 'https://etherscan.io',
    5: 'https://goerli.etherscan.io',
    11155111: 'https://sepolia.etherscan.io',
    137: 'https://polygonscan.com',
    80001: 'https://mumbai.polygonscan.com',
    56: 'https://bscscan.com',
    97: 'https://testnet.bscscan.com',
    42161: 'https://arbiscan.io',
    421614: 'https://sepolia.arbiscan.io',
    10: 'https://optimistic.etherscan.io',
    11155420: 'https://sepolia-optimism.etherscan.io',
    8453: 'https://basescan.org',
    84532: 'https://sepolia.basescan.org',
    17000: 'https://holesky.etherscan.io'
  };
  
  return etherscanUrls[chainId] || 'https://etherscan.io';
}


// Вспомогательные функции для получения названий и описаний модулей
function getModuleName(moduleId) {
  const moduleNames = {
    "0x7472656173757279000000000000000000000000000000000000000000000000": "TREASURY",
    "0x74696d656c6f636b000000000000000000000000000000000000000000000000": "TIMELOCK",
    "0x7265616465720000000000000000000000000000000000000000000000000000": "READER",
    "0x6d696e7400000000000000000000000000000000000000000000000000000000": "MINT",
    "0x6275726e00000000000000000000000000000000000000000000000000000000": "BURN",
    "0x6f7261636c650000000000000000000000000000000000000000000000000000": "ORACLE",
    "0x696e6865726974616e6365000000000000000000000000000000000000000000": "INHERITANCE",
    "0x636f6d6d756e69636174696f6e00000000000000000000000000000000000000": "COMMUNICATION",
    "0x6170706c69636174696f6e000000000000000000000000000000000000000000": "APPLICATION"
  };
  return moduleNames[moduleId] || "UNKNOWN";
}

function getModuleDescription(moduleId) {
  const moduleDescriptions = {
    "0x7472656173757279000000000000000000000000000000000000000000000000": "Казначейство DLE - управление финансами, депозиты, выводы, дивиденды",
    "0x74696d656c6f636b000000000000000000000000000000000000000000000000": "Модуль задержек исполнения - безопасность критических операций через таймлоки",
    "0x7265616465720000000000000000000000000000000000000000000000000000": "Модуль чтения данных DLE - получение информации о контракте",
    "0x6d696e7400000000000000000000000000000000000000000000000000000000": "Модуль выпуска токенов - создание дополнительных токенов DLE через governance",
    "0x6275726e00000000000000000000000000000000000000000000000000000000": "Модуль сжигания токенов - уменьшение общего предложения токенов DLE",
    "0x6f7261636c650000000000000000000000000000000000000000000000000000": "Модуль оракулов - получение внешних данных для автоматизации DLE",
    "0x696e6865726974616e6365000000000000000000000000000000000000000000": "Модуль наследования - передача прав и токенов между участниками DLE",
    "0x636f6d6d756e69636174696f6e00000000000000000000000000000000000000": "Модуль коммуникации - уведомления и взаимодействие между участниками DLE",
    "0x6170706c69636174696f6e000000000000000000000000000000000000000000": "Модуль заявок - обработка предложений и заявок участников DLE"
  };
  return moduleDescriptions[moduleId] || "Описание не найдено";
}

// Верификация модуля на Etherscan
router.post('/verify-module', async (req, res) => {
  try {
    const { dleAddress, moduleId, moduleAddress, moduleName } = req.body;
    
    if (!dleAddress || !moduleId || !moduleAddress || !moduleName) {
      return res.status(400).json({
        success: false,
        error: 'Все параметры обязательны: dleAddress, moduleId, moduleAddress, moduleName'
      });
    }

    console.log(`[DLE Modules] Верификация модуля ${moduleName} по адресу ${moduleAddress}`);

    // Получаем API ключ Etherscan из секретов
    const { getSecret } = require('../services/secretStore');
    let apiKey = await getSecret('ETHERSCAN_V2_API_KEY');
    
    if (!apiKey) {
      return res.status(500).json({
        success: false,
        error: 'API ключ Etherscan не найден в секретах'
      });
    }

    // Получаем chainId из параметров запроса
    const { chainId } = req.body;
    
    if (!chainId) {
      return res.status(400).json({
        success: false,
        error: 'chainId обязателен для верификации'
      });
    }
    
    // Определяем имя контракта на основе moduleId
    let contractName;
    if (moduleId === "0x7472656173757279000000000000000000000000000000000000000000000000") {
      contractName = "TreasuryModule";
    } else if (moduleId === "0x74696d656c6f636b000000000000000000000000000000000000000000000000") {
      contractName = "TimelockModule";
    } else if (moduleId === "0x7265616465720000000000000000000000000000000000000000000000000000") {
      contractName = "DLEReader";
    } else {
      contractName = "UnknownModule";
    }

    console.log(`[DLE Modules] Верификация ${contractName} на Etherscan...`);

    // Импортируем сервис верификации
    const etherscanV2 = require('../services/etherscanV2VerificationService');
    
    // Получаем RPC URL для Sepolia
    const rpcProviderService = require('../services/rpcProviderService');
    const rpcUrl = await rpcProviderService.getRpcUrlByChainId(chainId);
    
    if (!rpcUrl) {
      return res.status(500).json({
        success: false,
        error: 'RPC URL для Sepolia не найден'
      });
    }

    // Получаем ABI и bytecode для модуля
    const { ethers } = require('ethers');
    const provider = new ethers.JsonRpcProvider(rpcUrl);

    // Получаем код контракта для проверки существования
    const code = await provider.getCode(moduleAddress);
    
    if (code === '0x') {
      return res.status(400).json({
        success: false,
        error: 'По указанному адресу нет контракта'
      });
    }

    // Создаем стандартный JSON input для компиляции
    const standardJsonInput = await createStandardJsonInput(contractName, moduleAddress, dleAddress, chainId);

    // Отправляем верификацию на Etherscan
    const verificationResult = await etherscanV2.submitVerification({
      chainId: chainId,
      contractAddress: moduleAddress,
      contractName: `${contractName}.sol:${contractName}`, // Формат: filename.sol:contractname
      compilerVersion: "v0.8.20+commit.a1b79de6", // Версия компилятора (точно как в основном контракте)
      standardJsonInput: standardJsonInput.standardJsonInput,
      constructorArgsHex: standardJsonInput.constructorArgsHex,
      apiKey: apiKey
    });

    console.log(`[DLE Modules] Результат верификации:`, verificationResult);

    res.json({
      success: true,
      data: {
        message: `Модуль ${moduleName} успешно верифицирован`,
        verificationResult: verificationResult,
        contractName: contractName,
        moduleAddress: moduleAddress
      }
    });

  } catch (error) {
    console.error('[DLE Modules] Ошибка верификации модуля:', error);
    
    res.status(500).json({
      success: false,
      error: 'Ошибка верификации модуля: ' + error.message
    });
  }
});

// Получить информацию о поддерживаемых сетях
router.post('/get-networks-info', async (req, res) => {
  try {
    const { dleAddress } = req.body;
    
    if (!dleAddress) {
      return res.status(400).json({
        success: false,
        error: 'Адрес DLE обязателен'
      });
    }

    console.log(`[DLE Modules] Получение информации о сетях для DLE: ${dleAddress}`);

    // Получаем информацию о поддерживаемых сетях из DLE контракта
    const supportedNetworks = await getSupportedNetworksFromDLE(dleAddress);

    res.json({
      success: true,
      data: {
        networks: supportedNetworks,
        totalNetworks: supportedNetworks.length
      }
    });

  } catch (error) {
    console.error('[DLE Modules] Ошибка при получении информации о сетях:', error);
    res.status(500).json({
      success: false,
      error: 'Ошибка при получении информации о сетях: ' + error.message
    });
  }
});

// Проверить статус инициализации модулей
router.post('/check-modules-status', async (req, res) => {
  try {
    const { dleAddress } = req.body;
    
    if (!dleAddress) {
      return res.status(400).json({
        success: false,
        error: 'Адрес DLE обязателен'
      });
    }

    console.log(`[DLE Modules] Проверка статуса модулей для DLE: ${dleAddress}`);

    // Получаем поддерживаемые сети
    const supportedNetworks = await getSupportedNetworksFromDLE(dleAddress);
    
    if (supportedNetworks.length === 0) {
      return res.json({
        success: true,
        data: {
          requiresGovernance: true,
          initializer: null,
          modules: [],
          networks: []
        }
      });
    }

    // Проверяем первую доступную сеть
    const network = supportedNetworks[0];
    const provider = new ethers.JsonRpcProvider(network.rpcUrl);
    
    const dleAbi = [
      "function initializer() external view returns (address)",
      "function isModuleActive(bytes32 _moduleId) external view returns (bool)",
      "function getModuleAddress(bytes32 _moduleId) external view returns (address)"
    ];

    const dle = new ethers.Contract(dleAddress, dleAbi, provider);

    // Модули инициализируются только через governance
    const initializer = await dle.initializer();

    // Проверяем модули
    const moduleIds = MODULE_TYPE_TO_ID;

    const modules = [];
    for (const [name, moduleId] of Object.entries(moduleIds)) {
      try {
        const isActive = await dle.isModuleActive(moduleId);
        const address = await dle.getModuleAddress(moduleId);
        modules.push({
          name: name.toUpperCase(),
          moduleId: moduleId,
          isActive: isActive,
          address: address
        });
      } catch (error) {
        modules.push({
          name: name.toUpperCase(),
          moduleId: moduleId,
          isActive: false,
          address: null,
          error: error.message
        });
      }
    }

    res.json({
      success: true,
      data: {
        requiresGovernance: true,
        initializer: initializer,
        modules: modules,
        networks: supportedNetworks
      }
    });

  } catch (error) {
    console.error('[DLE Modules] Ошибка при проверке статуса модулей:', error);
    res.status(500).json({
      success: false,
      error: 'Ошибка при проверке статуса модулей: ' + error.message
    });
  }
});

// Функция для создания стандартного JSON input для верификации
async function createStandardJsonInput(contractName, moduleAddress, dleAddress, chainId) {
  const fs = require('fs');
  const path = require('path');
  
  try {
    // Читаем исходный код контракта
    let contractSource = '';
    let contractPath = '';
    
    if (contractName === 'TreasuryModule') {
      contractPath = path.join(__dirname, '../contracts/TreasuryModule.sol');
    } else if (contractName === 'TimelockModule') {
      contractPath = path.join(__dirname, '../contracts/TimelockModule.sol');
    } else if (contractName === 'DLEReader') {
      contractPath = path.join(__dirname, '../contracts/DLEReader.sol');
    } else {
      throw new Error(`Неизвестный контракт: ${contractName}`);
    }
    
    if (!fs.existsSync(contractPath)) {
      throw new Error(`Файл контракта не найден: ${contractPath}`);
    }
    
    contractSource = fs.readFileSync(contractPath, 'utf8');
    
    // Определяем конструктор аргументы на основе типа контракта
    let constructorArgs = [];
    
    if (contractName === 'TreasuryModule') {
      // TreasuryModule: [dleAddress, chainId, emergencyAdmin]
      // Нужно получить реальный emergencyAdmin из транзакции деплоя
      let emergencyAdmin = dleAddress; // fallback
      
      try {
        // Получаем emergencyAdmin из транзакции деплоя
        const provider = new ethers.JsonRpcProvider(await require('../services/rpcProviderService').getRpcUrlByChainId(chainId));
        const history = await provider.getHistory(moduleAddress);
        if (history.length > 0) {
          const deployTx = history[0]; // Первая транзакция - это деплой
          if (deployTx.from) {
            emergencyAdmin = deployTx.from; // deployer становится emergencyAdmin
            console.log(`[DLE Modules] Найден emergencyAdmin из транзакции деплоя: ${emergencyAdmin}`);
          }
        }
      } catch (error) {
        console.log(`[DLE Modules] Не удалось получить emergencyAdmin из транзакции: ${error.message}`);
      }
      
      constructorArgs = [dleAddress, chainId.toString(), emergencyAdmin];
    } else if (contractName === 'TimelockModule') {
      // TimelockModule: [dleAddress]
      constructorArgs = [dleAddress];
    } else if (contractName === 'DLEReader') {
      // DLEReader: [dleAddress]
      constructorArgs = [dleAddress];
    }
    
    // Кодируем конструктор аргументы
    const { ethers } = require('ethers');
    const abiCoder = new ethers.AbiCoder();
    
    let constructorArgsHex = '0x';
    if (constructorArgs.length > 0) {
      // Определяем типы параметров для каждого контракта
      let paramTypes = [];
      if (contractName === 'TreasuryModule') {
        paramTypes = ['address', 'uint256', 'address'];
      } else if (contractName === 'TimelockModule' || contractName === 'DLEReader') {
        paramTypes = ['address'];
      }
      
      constructorArgsHex = abiCoder.encode(paramTypes, constructorArgs);
    }
    
    // Создаем стандартный JSON input
    const standardJsonInput = {
      language: "Solidity",
      sources: {
        [contractName + '.sol']: {
          content: contractSource
        }
      },
      settings: {
        optimizer: {
          enabled: true,
          runs: 200
        },
        evmVersion: "paris",
        outputSelection: {
          "*": {
            "*": ["*"]
          }
        },
        libraries: {},
        remappings: [
          "@openzeppelin/contracts/=node_modules/@openzeppelin/contracts/"
        ]
      }
    };
    
    console.log(`[DLE Modules] Создан standardJsonInput для ${contractName}:`, {
      contractPath,
      constructorArgs,
      constructorArgsHex,
      sourceLength: contractSource.length
    });
    
    return {
      standardJsonInput: JSON.stringify(standardJsonInput),
      constructorArgsHex: constructorArgsHex
    };
    
  } catch (error) {
    console.error(`[DLE Modules] Ошибка создания standardJsonInput для ${contractName}:`, error);
    throw error;
  }
}

// Мультиинициализация модулей во всех сетях
router.post('/initialize-modules-all-networks', async (req, res) => {
  try {
    const { dleAddress, privateKey } = req.body;
    
    if (!dleAddress || !privateKey) {
      return res.status(400).json({
        success: false,
        error: 'Адрес DLE и приватный ключ обязательны'
      });
    }

    console.log(`[DLE Modules] Мультиинициализация модулей для DLE: ${dleAddress}`);

    // Получаем поддерживаемые сети
    const supportedNetworks = await getSupportedNetworksFromDLE(dleAddress);
    
    if (supportedNetworks.length === 0) {
      return res.status(400).json({
        success: false,
        error: 'Не найдены поддерживаемые сети для DLE'
      });
    }

    const results = [];
    const dleAbi = [
      "function getModuleAddress(bytes32 _moduleId) external view returns (address)",
      "function isModuleActive(bytes32 _moduleId) external view returns (bool)"
    ];

    // ID модулей
    const moduleIds = MODULE_TYPE_TO_ID;

    for (const network of supportedNetworks) {
      console.log(`[DLE Modules] Инициализация модулей в сети: ${network.networkName} (${network.chainId})`);
      
      try {
        const provider = new ethers.JsonRpcProvider(network.rpcUrl);
        const wallet = new ethers.Wallet(privateKey, provider);
        const dle = new ethers.Contract(dleAddress, dleAbi, wallet);

        // Модули инициализируются только через governance
        console.log(`[DLE Modules] Модули инициализируются через governance предложения в сети ${network.chainId}`);

        // Получаем адреса модулей
        const treasuryAddress = await dle.getModuleAddress(moduleIds.treasury);
        const timelockAddress = await dle.getModuleAddress(moduleIds.timelock);
        const readerAddress = await dle.getModuleAddress(moduleIds.reader);

        // Проверяем, что все модули задеплоены
        if (treasuryAddress === "0x0000000000000000000000000000000000000000" ||
            timelockAddress === "0x0000000000000000000000000000000000000000" ||
            readerAddress === "0x0000000000000000000000000000000000000000") {
          console.log(`[DLE Modules] Не все модули задеплоены в сети ${network.chainId}`);
          results.push({
            chainId: network.chainId,
            networkName: network.networkName,
            status: 'modules_not_deployed',
            message: 'Не все модули задеплоены'
          });
          continue;
        }

        // Модули инициализируются только через governance предложения
        console.log(`[DLE Modules] Модули должны быть инициализированы через governance предложения в сети ${network.chainId}`);
        results.push({
          chainId: network.chainId,
          networkName: network.networkName,
          status: 'requires_governance',
          message: 'Модули должны быть инициализированы через governance предложения',
          treasuryAddress,
          timelockAddress,
          readerAddress
        });

      } catch (error) {
        console.error(`[DLE Modules] Ошибка инициализации модулей в сети ${network.chainId}:`, error.message);
        results.push({
          chainId: network.chainId,
          networkName: network.networkName,
          status: 'error',
          message: error.message
        });
      }
    }

    res.json({
      success: true,
      data: {
        results: results,
        summary: {
          total: results.length,
          success: results.filter(r => r.status === 'success').length,
          already_initialized: results.filter(r => r.status === 'already_initialized').length,
          errors: results.filter(r => r.status === 'error').length
        }
      }
    });

  } catch (error) {
    console.error('[DLE Modules] Ошибка мультиинициализации модулей:', error);
    res.status(500).json({
      success: false,
      error: 'Ошибка мультиинициализации модулей: ' + error.message
    });
  }
});

// Мультиверификация модулей во всех сетях
router.post('/verify-modules-all-networks', async (req, res) => {
  try {
    const { dleAddress, privateKey } = req.body;
    
    if (!dleAddress || !privateKey) {
      return res.status(400).json({
        success: false,
        error: 'Адрес DLE и приватный ключ обязательны'
      });
    }

    console.log(`[DLE Modules] Мультиверификация модулей для DLE: ${dleAddress}`);

    // Получаем поддерживаемые сети
    const supportedNetworks = await getSupportedNetworksFromDLE(dleAddress);
    
    if (supportedNetworks.length === 0) {
      return res.status(400).json({
        success: false,
        error: 'Не найдены поддерживаемые сети для DLE'
      });
    }

    const results = [];
    const dleAbi = [
      "function getModuleAddress(bytes32 _moduleId) external view returns (address)"
    ];

    // ID модулей
    const moduleIds = MODULE_TYPE_TO_ID;

    // Маппинг модулей для верификации
    const moduleTypes = {
      treasury: 'TreasuryModule',
      timelock: 'TimelockModule', 
      reader: 'DLEReader'
    };

    for (const network of supportedNetworks) {
      console.log(`[DLE Modules] Верификация модулей в сети: ${network.networkName} (${network.chainId})`);
      
      const networkResults = {
        chainId: network.chainId,
        networkName: network.networkName,
        modules: {}
      };

      try {
        const provider = new ethers.JsonRpcProvider(network.rpcUrl);
        const dle = new ethers.Contract(dleAddress, dleAbi, provider);

        for (const [moduleKey, moduleId] of Object.entries(moduleIds)) {
          try {
            const moduleAddress = await dle.getModuleAddress(moduleId);
            
            if (moduleAddress === "0x0000000000000000000000000000000000000000") {
              networkResults.modules[moduleKey] = {
                status: 'not_deployed',
                message: 'Модуль не задеплоен'
              };
              continue;
            }

            // Верифицируем модуль
            const verificationResult = await verifyModuleInNetwork(
              moduleTypes[moduleKey],
              moduleAddress,
              dleAddress,
              network.chainId,
              network.networkName
            );

            networkResults.modules[moduleKey] = verificationResult;

          } catch (error) {
            console.error(`[DLE Modules] Ошибка верификации модуля ${moduleKey} в сети ${network.chainId}:`, error.message);
            networkResults.modules[moduleKey] = {
              status: 'error',
              message: error.message
            };
          }
        }

      } catch (error) {
        console.error(`[DLE Modules] Ошибка подключения к сети ${network.chainId}:`, error.message);
        networkResults.error = error.message;
      }

      results.push(networkResults);
    }

    res.json({
      success: true,
      data: {
        results: results,
        summary: {
          total_networks: results.length,
          total_modules: results.length * 3, // 3 модуля на сеть
          success_count: results.reduce((sum, r) => 
            sum + Object.values(r.modules || {}).filter(m => m.status === 'success').length, 0),
          error_count: results.reduce((sum, r) => 
            sum + Object.values(r.modules || {}).filter(m => m.status === 'error').length, 0)
        }
      }
    });

  } catch (error) {
    console.error('[DLE Modules] Ошибка мультиверификации модулей:', error);
    res.status(500).json({
      success: false,
      error: 'Ошибка мультиверификации модулей: ' + error.message
    });
  }
});

// Вспомогательная функция для верификации модуля в конкретной сети
async function verifyModuleInNetwork(contractName, moduleAddress, dleAddress, chainId, networkName) {
  try {
    console.log(`[DLE Modules] Верификация ${contractName} в сети ${networkName} (${chainId})`);
    
    // Получаем Etherscan URL для сети
    const etherscanUrl = await getEtherscanUrlByChainId(chainId);
    if (!etherscanUrl) {
      return {
        status: 'error',
        message: `Etherscan не поддерживается для сети ${networkName}`
      };
    }

    // Получаем API ключ Etherscan из секретов
    const { getSecret } = require('../services/secretStore');
    const apiKey = await getSecret('ETHERSCAN_V2_API_KEY');
    
    if (!apiKey) {
      return {
        status: 'error',
        message: 'API ключ Etherscan не найден в секретах'
      };
    }

    // Создаем стандартный JSON input для верификации
    const standardJsonInput = await createStandardJsonInput(contractName, moduleAddress, dleAddress, chainId);
    
    // Отправляем запрос на верификацию
    const verificationResponse = await fetch(`${etherscanUrl}/api`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/x-www-form-urlencoded',
      },
      body: new URLSearchParams({
        apikey: apiKey,
        module: 'contract',
        action: 'verifysourcecode',
        contractaddress: moduleAddress,
        codeformat: 'solidity-standard-json-input',
        contractname: contractName,
        sourceCode: JSON.stringify(standardJsonInput),
        compilerversion: 'v0.8.20+commit.a1b79de6',
        optimizationUsed: '1',
        runs: '1'
      })
    });

    const verificationData = await verificationResponse.json();
    
    if (verificationData.status === '1') {
      console.log(`[DLE Modules] ${contractName} успешно верифицирован в сети ${networkName}`);
      return {
        status: 'success',
        message: 'Модуль успешно верифицирован',
        guid: verificationData.result
      };
    } else {
      console.log(`[DLE Modules] Ошибка верификации ${contractName} в сети ${networkName}: ${verificationData.result}`);
      return {
        status: 'failed',
        message: verificationData.result || 'Ошибка верификации'
      };
    }
    
    } catch (error) {
    console.error(`[DLE Modules] Ошибка верификации ${contractName} в сети ${networkName}:`, error);
    return {
      status: 'error',
      message: error.message
    };
  }
}

// Проверка статуса деплоя DLE контракта во всех сетях
router.post('/check-dle-deployment-status', async (req, res) => {
  try {
    const { dleAddress, chainIds, maxRetries = 1, retryDelay = 30000 } = req.body;
    
    if (!dleAddress || !chainIds || !Array.isArray(chainIds)) {
      return res.status(400).json({
        success: false,
        error: 'Адрес DLE и список chainIds обязательны'
      });
    }

    console.log(`[DLE Modules] Проверка статуса деплоя DLE: ${dleAddress} в сетях: ${chainIds.join(', ')}`);

    const results = [];
    let allSuccessful = true;

    for (const chainId of chainIds) {
      console.log(`[DLE Modules] Проверка DLE в сети: ${chainId}`);
      
      try {
        const result = await executeWithRetries(
          async () => {
            const rpcUrl = await rpcProviderService.getRpcUrlByChainId(chainId);
            if (!rpcUrl) {
              throw new Error(`RPC URL не найден для сети ${chainId}`);
            }

            const provider = new ethers.JsonRpcProvider(rpcUrl);
            
            // Проверяем, что контракт существует и имеет код
            const code = await provider.getCode(dleAddress);
            
            if (code === '0x') {
              return {
                chainId: chainId,
                status: 'not_deployed',
                message: 'Контракт не задеплоен'
              };
            } else {
              // Проверяем, что это действительно DLE контракт
              const dleAbi = [
                "function name() external view returns (string)",
                "function symbol() external view returns (string)",
              ];
              
              const dle = new ethers.Contract(dleAddress, dleAbi, provider);
              // Проверяем что контракт развернут (код не пустой)
              const code = await provider.getCode(dleAddress);
              if (code === '0x' || code.length <= 2) {
                throw new Error('Контракт не развернут');
              }
              const name = 'DLE'; // Используем фиксированное имя
              const symbol = 'DLE'; // Используем фиксированный символ
              
              return {
                chainId: chainId,
                status: 'success',
                message: 'DLE контракт успешно задеплоен',
                contractInfo: {
                  name: name,
                  symbol: symbol,
                  hasCode: true
                }
              };
            }
          },
          `Проверка DLE в сети ${chainId}`,
          maxRetries,
          retryDelay
        );

        results.push(result);
        
        if (result.status !== 'success') {
          allSuccessful = false;
    }
    
  } catch (error) {
        console.error(`[DLE Modules] Ошибка при проверке DLE в сети ${chainId}:`, error.message);
        results.push({
          chainId: chainId,
          status: 'error',
          message: error.message,
          attempts: maxRetries
        });
        allSuccessful = false;
      }
    }

    res.json({
      success: true,
      data: {
        dleAddress: dleAddress,
        results: results,
        summary: {
          total: results.length,
          success: results.filter(r => r.status === 'success').length,
          not_deployed: results.filter(r => r.status === 'not_deployed').length,
          errors: results.filter(r => r.status === 'error').length,
          allSuccessful: allSuccessful
        },
        canProceed: allSuccessful,
        nextAction: allSuccessful ? 'verify_dle' : 'retry_check'
      }
    });

  } catch (error) {
    console.error('[DLE Modules] Ошибка проверки статуса деплоя DLE:', error);
    res.status(500).json({
      success: false,
      error: 'Ошибка проверки статуса деплоя DLE: ' + error.message
    });
  }
});

// Проверка статуса деплоя конкретного модуля во всех сетях
router.post('/check-module-deployment-status', async (req, res) => {
  try {
    const { dleAddress, moduleType, chainIds, maxRetries = 1, retryDelay = 30000 } = req.body;
    
    if (!dleAddress || !moduleType || !chainIds || !Array.isArray(chainIds)) {
      return res.status(400).json({
        success: false,
        error: 'Адрес DLE, тип модуля и список chainIds обязательны'
      });
    }

    console.log(`[DLE Modules] Проверка статуса деплоя модуля ${moduleType} для DLE: ${dleAddress} в сетях: ${chainIds.join(', ')}`);

    // Маппинг типов модулей на их ID
    const moduleIds = MODULE_TYPE_TO_ID;

    const moduleId = moduleIds[moduleType];
    if (!moduleId) {
      return res.status(400).json({
        success: false,
        error: `Неизвестный тип модуля: ${moduleType}. Поддерживаемые типы: ${Object.keys(moduleIds).join(', ')}`
      });
    }

    const results = [];
    let allSuccessful = true;

    for (const chainId of chainIds) {
      console.log(`[DLE Modules] Проверка модуля ${moduleType} в сети: ${chainId}`);
      
      try {
        const result = await executeWithRetries(
          async () => {
            const rpcUrl = await rpcProviderService.getRpcUrlByChainId(chainId);
            if (!rpcUrl) {
              throw new Error(`RPC URL не найден для сети ${chainId}`);
            }

            const provider = new ethers.JsonRpcProvider(rpcUrl);
            
            const dleAbi = [
              "function getModuleAddress(bytes32 _moduleId) external view returns (address)",
              "function isModuleActive(bytes32 _moduleId) external view returns (bool)"
            ];
            
            const dle = new ethers.Contract(dleAddress, dleAbi, provider);
            
            // Получаем адрес модуля
            const moduleAddress = await dle.getModuleAddress(moduleId);
            
            if (moduleAddress === "0x0000000000000000000000000000000000000000") {
              return {
                chainId: chainId,
                status: 'not_deployed',
                message: `Модуль ${moduleType} не задеплоен`
              };
            } else {
              // Проверяем, что контракт модуля существует и имеет код
              const code = await provider.getCode(moduleAddress);
              
              if (code === '0x') {
                throw new Error(`Адрес модуля найден, но контракт не задеплоен: ${moduleAddress}`);
              } else {
                // Проверяем активность модуля
                const isActive = await dle.isModuleActive(moduleId);
                
                return {
                  chainId: chainId,
                  status: 'success',
                  message: `Модуль ${moduleType} успешно задеплоен`,
                  moduleInfo: {
                    address: moduleAddress,
                    isActive: isActive,
                    hasCode: true
                  }
                };
              }
            }
          },
          `Проверка модуля ${moduleType} в сети ${chainId}`,
          maxRetries,
          retryDelay
        );

        results.push(result);
        
        if (result.status !== 'success') {
          allSuccessful = false;
        }

      } catch (error) {
        console.error(`[DLE Modules] Ошибка при проверке модуля ${moduleType} в сети ${chainId}:`, error.message);
        results.push({
          chainId: chainId,
          status: 'error',
          message: error.message,
          attempts: maxRetries
        });
        allSuccessful = false;
      }
    }

    res.json({
      success: true,
      data: {
        dleAddress: dleAddress,
        moduleType: moduleType,
        moduleId: moduleId,
        results: results,
        summary: {
          total: results.length,
          success: results.filter(r => r.status === 'success').length,
          not_deployed: results.filter(r => r.status === 'not_deployed').length,
          errors: results.filter(r => r.status === 'error').length,
          allSuccessful: allSuccessful
        },
        canProceed: allSuccessful,
        nextAction: allSuccessful ? 'verify_module' : 'retry_check'
      }
    });

  } catch (error) {
    console.error('[DLE Modules] Ошибка проверки статуса деплоя модуля:', error);
    res.status(500).json({
      success: false,
      error: 'Ошибка проверки статуса деплоя модуля: ' + error.message
    });
  }
});

// Деплой одного модуля во всех сетях
router.post('/deploy-module-all-networks', async (req, res) => {
  try {
    const { dleAddress, moduleType, privateKey, maxRetries = 1, retryDelay = 45000 } = req.body;
    
    if (!dleAddress || !moduleType || !privateKey) {
      return res.status(400).json({
        success: false,
        error: 'Адрес DLE, тип модуля и приватный ключ обязательны'
      });
    }

    console.log(`[DLE Modules] Деплой модуля ${moduleType} для DLE: ${dleAddress}`);

    // Автоматическая компиляция контрактов перед деплоем
    try {
      await autoCompileContracts();
    } catch (compileError) {
      console.error(`[DLE Modules] Ошибка при компиляции контрактов:`, compileError.message);
      return res.status(500).json({
        success: false,
        error: `Ошибка компиляции контрактов: ${compileError.message}`
      });
    }

    // Получаем поддерживаемые сети
    const supportedNetworks = await getSupportedNetworksFromDLE(dleAddress);
    
    if (supportedNetworks.length === 0) {
      return res.status(400).json({
        success: false,
        error: 'Не найдены поддерживаемые сети для DLE'
      });
    }

    // Маппинг типов модулей на их конфигурацию
    const moduleConfigs = {
      treasury: {
        contractName: 'TreasuryModule',
        constructorArgs: (dleAddress, chainId, deployerAddress) => [dleAddress, chainId, deployerAddress]
      },
      timelock: {
        contractName: 'TimelockModule',
        constructorArgs: (dleAddress) => [dleAddress]
      },
      reader: {
        contractName: 'DLEReader',
        constructorArgs: (dleAddress) => [dleAddress]
      }
    };

    const moduleConfig = moduleConfigs[moduleType];
    if (!moduleConfig) {
      return res.status(400).json({
        success: false,
        error: `Неизвестный тип модуля: ${moduleType}. Поддерживаемые типы: ${Object.keys(moduleConfigs).join(', ')}`
      });
    }

    const results = [];
    let allSuccessful = true;

    for (const network of supportedNetworks) {
      console.log(`[DLE Modules] Деплой модуля ${moduleType} в сети: ${network.networkName} (${network.chainId})`);
      
      try {
        const result = await executeWithRetries(
          async () => {
            const provider = new ethers.JsonRpcProvider(network.rpcUrl);
            const wallet = new ethers.Wallet(privateKey, provider);
            
            // Получаем текущий nonce
            const currentNonce = await wallet.getNonce();
            console.log(`[DLE Modules] Текущий nonce для сети ${network.chainId}: ${currentNonce}`);

            // Получаем фабрику контракта
            const ContractFactory = await hre.ethers.getContractFactory(moduleConfig.contractName);
            
            // Подготавливаем аргументы конструктора
            const constructorArgs = moduleConfig.constructorArgs(dleAddress, network.chainId, wallet.address);
            
            console.log(`[DLE Modules] Деплой ${moduleConfig.contractName} с аргументами:`, constructorArgs);
            
            // Деплоим контракт
            const contract = await ContractFactory.connect(wallet).deploy(...constructorArgs);
            await contract.waitForDeployment();
            
            const deployedAddress = await contract.getAddress();
            console.log(`[DLE Modules] Модуль ${moduleType} задеплоен в сети ${network.chainId}: ${deployedAddress}`);

            return {
              chainId: network.chainId,
              networkName: network.networkName,
              status: 'success',
              message: `Модуль ${moduleType} успешно задеплоен`,
              moduleAddress: deployedAddress,
              transactionHash: contract.deploymentTransaction().hash,
              nonce: currentNonce
            };
          },
          `Деплой модуля ${moduleType} в сети ${network.networkName} (${network.chainId})`,
          maxRetries,
          retryDelay
        );

        results.push(result);

      } catch (error) {
        console.error(`[DLE Modules] Ошибка деплоя модуля ${moduleType} в сети ${network.chainId}:`, error.message);
        results.push({
          chainId: network.chainId,
          networkName: network.networkName,
          status: 'error',
          message: error.message,
          attempts: maxRetries
        });
        allSuccessful = false;
      }
    }

    res.json({
      success: true,
      data: {
        dleAddress: dleAddress,
        moduleType: moduleType,
        results: results,
        summary: {
          total: results.length,
          success: results.filter(r => r.status === 'success').length,
          errors: results.filter(r => r.status === 'error').length,
          allSuccessful: allSuccessful
        },
        canProceed: allSuccessful,
        nextAction: allSuccessful ? 'check_module_deployment' : 'retry_deployment'
      }
    });

  } catch (error) {
    console.error('[DLE Modules] Ошибка деплоя модуля:', error);
    res.status(500).json({
      success: false,
      error: 'Ошибка деплоя модуля: ' + error.message
    });
  }
});

// Верификация DLE контракта во всех сетях
router.post('/verify-dle-all-networks', async (req, res) => {
  try {
    const { dleAddress, privateKey, maxRetries = 1, retryDelay = 60000 } = req.body;
    
    if (!dleAddress || !privateKey) {
      return res.status(400).json({
        success: false,
        error: 'Адрес DLE и приватный ключ обязательны'
      });
    }

    console.log(`[DLE Modules] Верификация DLE контракта: ${dleAddress}`);

    // Получаем поддерживаемые сети
    const supportedNetworks = await getSupportedNetworksFromDLE(dleAddress);
    
    if (supportedNetworks.length === 0) {
      return res.status(400).json({
        success: false,
        error: 'Не найдены поддерживаемые сети для DLE'
      });
    }

    const results = [];
    let allSuccessful = true;

    for (const network of supportedNetworks) {
      console.log(`[DLE Modules] Верификация DLE в сети: ${network.networkName} (${network.chainId})`);
      
      try {
        const result = await executeWithRetries(
          async () => {
            // Получаем Etherscan URL для сети
            const etherscanUrl = await getEtherscanUrlByChainId(network.chainId);
            if (!etherscanUrl) {
              throw new Error(`Etherscan не поддерживается для сети ${network.networkName}`);
            }

              // Берем параметры из сохраненной карточки DLE и не делаем on-chain вызовы
              const fs = require('fs');
              const path = require('path');
              const dlesDir = path.join(__dirname, '../contracts-data/dles');

              let saved = null;
              if (fs.existsSync(dlesDir)) {
                for (const f of fs.readdirSync(dlesDir)) {
                  if (!f.endsWith('.json')) continue;
                  const data = JSON.parse(fs.readFileSync(path.join(dlesDir, f), 'utf8'));
                  if (data && data.dleAddress && data.dleAddress.toLowerCase() === dleAddress.toLowerCase()) {
                    saved = data; break;
                  }
                }
              }

              // Фолбэки если карточка не найдена
              const name = saved?.name || 'DLE';
              const symbol = saved?.symbol || 'DLE';
              const location = saved?.location || '';
              const coordinates = saved?.coordinates || '';
              const jurisdiction = saved?.jurisdiction ?? 0;
              const oktmo = saved?.oktmo || '';
              const kpp = saved?.kpp ? Number(saved.kpp) : 0;
              const quorumPercentage = saved?.quorumPercentage ?? saved?.governanceSettings?.quorumPercentage ?? 51;

              // Инициализатор — адрес из переданного приватного ключа
              let initializer;
              try {
                const pk = privateKey.startsWith('0x') ? privateKey : `0x${privateKey}`;
                initializer = new ethers.Wallet(pk).address;
              } catch (_) {
                initializer = (saved?.initialPartners && saved.initialPartners[0]) || "0x0000000000000000000000000000000000000000";
              }

              // Список поддерживаемых сетей и текущая сеть
              const supportedChainIds = Array.isArray(saved?.networks)
                ? saved.networks.map(n => Number(n.chainId)).filter(v => !isNaN(v))
                : (saved?.governanceSettings?.supportedChainIds || []);
              const currentChainId = Number(saved?.governanceSettings?.currentChainId || network.chainId);

            // Создаем стандартный JSON input для верификации
            const standardJsonInput = {
              language: "Solidity",
              sources: {
                "DLE.sol": {
                  content: require('fs').readFileSync(require('path').join(__dirname, '../contracts/DLE.sol'), 'utf8')
                }
              },
              settings: {
                optimizer: {
                  enabled: true,
                  runs: 1
                },
                viaIR: true,
                outputSelection: {
                  "*": {
                    "*": ["*"]
                  }
                }
              }
            };

            // Получаем API ключ Etherscan из секретов
            const { getSecret } = require('../services/secretStore');
            const apiKey = await getSecret('ETHERSCAN_V2_API_KEY');
            
            if (!apiKey) {
              throw new Error('API ключ Etherscan не найден в секретах');
            }

            // Отправляем запрос на верификацию согласно Etherscan V2 API
            const verificationResponse = await fetch(`${etherscanUrl}/v2/api`, {
              method: 'POST',
              headers: {
                'Content-Type': 'application/x-www-form-urlencoded',
              },
              body: new URLSearchParams({
                chainid: network.chainId.toString(),
                apikey: apiKey,
                module: 'contract',
                action: 'verifysourcecode',
                contractaddress: dleAddress,
                codeformat: 'solidity-standard-json-input',
                contractname: 'DLE.sol:DLE',
                sourceCode: JSON.stringify(standardJsonInput),
                compilerversion: 'v0.8.20+commit.a1b79de6',
                constructorArguements: (async () => {
                  try {
                    const fs = require('fs');
                    const path = require('path');
                    const dlesDir = path.join(__dirname, '../contracts-data/dles');
                    let found = null;
                    if (fs.existsSync(dlesDir)) {
                      for (const f of fs.readdirSync(dlesDir)) {
                        if (!f.endsWith('.json')) continue;
                        const data = JSON.parse(fs.readFileSync(path.join(dlesDir, f), 'utf8'));
                        if (data && data.dleAddress && data.dleAddress.toLowerCase() === dleAddress.toLowerCase()) {
                          found = data; break;
                        }
                      }
                    }
                    const initPartners = Array.isArray(found?.initialPartners) ? found.initialPartners : [];
                    const initAmounts = Array.isArray(found?.initialAmounts) ? found.initialAmounts : [];
                    const scIds = Array.isArray(found?.networks) ? found.networks.map(n => Number(n.chainId)).filter(v => !isNaN(v)) : supportedChainIds;
                    const currentCid = Number(found?.governanceSettings?.currentChainId || found?.networks?.[0]?.chainId || network.chainId);
                    const encoded = ethers.AbiCoder.defaultAbiCoder().encode(
                      ['tuple(string,string,string,string,uint256,string,uint256,uint256,address[],uint256[],uint256[])', 'uint256', 'address'],
                      [[name, symbol, location, coordinates, jurisdiction, oktmo, kpp, quorumPercentage, initPartners, initAmounts.map(a => BigInt(a)), scIds], BigInt(currentCid), initializer]
                    );
                    return encoded;
                  } catch (_) {
                    // Fallback на пустые массивы при отсутствии сохраненных параметров
                    return ethers.AbiCoder.defaultAbiCoder().encode(
                      ['tuple(string,string,string,string,uint256,string,uint256,uint256,address[],uint256[],uint256[])', 'uint256', 'address'],
                      [[name, symbol, location, coordinates, jurisdiction, oktmo, kpp, quorumPercentage, [], [], supportedChainIds], BigInt(network.chainId), initializer]
                    );
                  }
                })()
              })
            });

            const verificationData = await verificationResponse.json();
            
            if (verificationData.status === '1') {
              console.log(`[DLE Modules] DLE отправлен на верификацию в сети ${network.networkName}, GUID: ${verificationData.result}`);
              
              // Проверяем статус верификации согласно best practices
              const guid = verificationData.result;
              let verificationStatus = 'pending';
              let attempts = 0;
              const maxStatusChecks = 10;
              
              while (verificationStatus === 'pending' && attempts < maxStatusChecks) {
                await new Promise(resolve => setTimeout(resolve, 5000)); // Ждем 5 секунд
                attempts++;
                
                try {
                  const statusResponse = await fetch(`${etherscanUrl}/v2/api?chainid=${network.chainId}&module=contract&action=checkverifystatus&guid=${guid}&apikey=${apiKey}`);
                  const statusData = await statusResponse.json();
                  
                  if (statusData.status === '1') {
                    verificationStatus = 'success';
                    console.log(`[DLE Modules] DLE успешно верифицирован в сети ${network.networkName}`);
                  } else if (statusData.result && statusData.result.includes('Fail')) {
                    verificationStatus = 'failed';
                    throw new Error(`Верификация не удалась: ${statusData.result}`);
                  }
                  // Если статус все еще pending, продолжаем проверку
                } catch (statusError) {
                  console.log(`[DLE Modules] Ошибка проверки статуса верификации (попытка ${attempts}): ${statusError.message}`);
                }
              }
              
              if (verificationStatus === 'success') {
                return {
                  chainId: network.chainId,
                  networkName: network.networkName,
                  status: 'success',
                  message: 'DLE контракт успешно верифицирован',
                  guid: guid,
                  etherscanUrl: `${etherscanUrl}/address/${dleAddress}`
                };
              } else {
                throw new Error('Верификация не завершена в течение ожидаемого времени');
              }
            } else {
              throw new Error(verificationData.result || 'Ошибка отправки на верификацию');
            }
          },
          `Верификация DLE в сети ${network.networkName} (${network.chainId})`,
          maxRetries,
          retryDelay
        );

        results.push(result);

      } catch (error) {
        console.error(`[DLE Modules] Ошибка верификации DLE в сети ${network.chainId}:`, error.message);
        results.push({
          chainId: network.chainId,
          networkName: network.networkName,
          status: 'error',
          message: error.message,
          attempts: maxRetries
        });
        allSuccessful = false;
      }
    }

    res.json({
      success: true,
      data: {
        dleAddress: dleAddress,
        results: results,
        summary: {
          total: results.length,
          success: results.filter(r => r.status === 'success').length,
          failed: results.filter(r => r.status === 'failed').length,
          errors: results.filter(r => r.status === 'error').length,
          allSuccessful: allSuccessful
        },
        canProceed: allSuccessful,
        nextAction: allSuccessful ? 'deploy_treasury_module' : 'retry_verification'
      }
    });

  } catch (error) {
    console.error('[DLE Modules] Ошибка верификации DLE:', error);
    res.status(500).json({
      success: false,
      error: 'Ошибка верификации DLE: ' + error.message
    });
  }
});

// Верификация одного модуля во всех сетях
router.post('/verify-module-all-networks', async (req, res) => {
  try {
    const { dleAddress, moduleType, privateKey, maxRetries = 1, retryDelay = 60000 } = req.body;
    
    if (!dleAddress || !moduleType || !privateKey) {
      return res.status(400).json({
        success: false,
        error: 'Адрес DLE, тип модуля и приватный ключ обязательны'
      });
    }

    console.log(`[DLE Modules] Верификация модуля ${moduleType} для DLE: ${dleAddress}`);

    // Получаем поддерживаемые сети
    const supportedNetworks = await getSupportedNetworksFromDLE(dleAddress);
    
    if (supportedNetworks.length === 0) {
      return res.status(400).json({
        success: false,
        error: 'Не найдены поддерживаемые сети для DLE'
      });
    }

    // Маппинг типов модулей на их ID
    const moduleIds = MODULE_TYPE_TO_ID;

    const moduleId = moduleIds[moduleType];
    if (!moduleId) {
      return res.status(400).json({
        success: false,
        error: `Неизвестный тип модуля: ${moduleType}. Поддерживаемые типы: ${Object.keys(moduleIds).join(', ')}`
      });
    }

    const results = [];
    let allSuccessful = true;

    for (const network of supportedNetworks) {
      console.log(`[DLE Modules] Верификация модуля ${moduleType} в сети: ${network.networkName} (${network.chainId})`);
      
      try {
        const result = await executeWithRetries(
          async () => {
            const provider = new ethers.JsonRpcProvider(network.rpcUrl);
            const dle = new ethers.Contract(dleAddress, [
              "function getModuleAddress(bytes32 _moduleId) external view returns (address)"
            ], provider);

            // Получаем адрес модуля
            const moduleAddress = await dle.getModuleAddress(moduleId);
            
            if (moduleAddress === "0x0000000000000000000000000000000000000000") {
              return {
                chainId: network.chainId,
                networkName: network.networkName,
                status: 'not_deployed',
                message: `Модуль ${moduleType} не задеплоен`
              };
            }

            // Верифицируем модуль
            const verificationResult = await verifyModuleInNetwork(
              moduleType,
              moduleAddress,
              dleAddress,
              network.chainId,
              network.networkName
            );

            return {
              chainId: network.chainId,
              networkName: network.networkName,
              ...verificationResult
            };
          },
          `Верификация модуля ${moduleType} в сети ${network.networkName} (${network.chainId})`,
          maxRetries,
          retryDelay
        );

        results.push(result);

        if (result.status !== 'success') {
          allSuccessful = false;
        }

      } catch (error) {
        console.error(`[DLE Modules] Ошибка верификации модуля ${moduleType} в сети ${network.chainId}:`, error.message);
        results.push({
          chainId: network.chainId,
          networkName: network.networkName,
          status: 'error',
          message: error.message,
          attempts: maxRetries
        });
        allSuccessful = false;
      }
    }

    res.json({
      success: true,
      data: {
        dleAddress: dleAddress,
        moduleType: moduleType,
        moduleId: moduleId,
        results: results,
        summary: {
          total: results.length,
          success: results.filter(r => r.status === 'success').length,
          failed: results.filter(r => r.status === 'failed').length,
          not_deployed: results.filter(r => r.status === 'not_deployed').length,
          errors: results.filter(r => r.status === 'error').length,
          allSuccessful: allSuccessful
        },
        canProceed: allSuccessful,
        nextAction: allSuccessful ? 'initialize_module' : 'retry_verification'
      }
    });

  } catch (error) {
    console.error('[DLE Modules] Ошибка верификации модуля:', error);
    res.status(500).json({
      success: false,
      error: 'Ошибка верификации модуля: ' + error.message
    });
  }
});

// Инициализация одного модуля во всех сетях
router.post('/initialize-module-all-networks', async (req, res) => {
  try {
    const { dleAddress, moduleType, privateKey, maxRetries = 1, retryDelay = 30000 } = req.body;
    
    if (!dleAddress || !moduleType || !privateKey) {
      return res.status(400).json({
        success: false,
        error: 'Адрес DLE, тип модуля и приватный ключ обязательны'
      });
    }

    console.log(`[DLE Modules] Инициализация модуля ${moduleType} для DLE: ${dleAddress}`);

    // Автоматическая компиляция контрактов перед инициализацией
    try {
      await autoCompileContracts();
    } catch (compileError) {
      console.error(`[DLE Modules] Ошибка при компиляции контрактов:`, compileError.message);
      return res.status(500).json({
        success: false,
        error: `Ошибка компиляции контрактов: ${compileError.message}`
      });
    }

    // Получаем поддерживаемые сети
    const supportedNetworks = await getSupportedNetworksFromDLE(dleAddress);
    
    if (supportedNetworks.length === 0) {
      return res.status(400).json({
        success: false,
        error: 'Не найдены поддерживаемые сети для DLE'
      });
    }

    // Маппинг типов модулей на их ID
    const moduleIds = MODULE_TYPE_TO_ID;

    const moduleId = moduleIds[moduleType];
    if (!moduleId) {
      return res.status(400).json({
        success: false,
        error: `Неизвестный тип модуля: ${moduleType}. Поддерживаемые типы: ${Object.keys(moduleIds).join(', ')}`
      });
    }

    const results = [];
    let allSuccessful = true;

    for (const network of supportedNetworks) {
      console.log(`[DLE Modules] Инициализация модуля ${moduleType} в сети: ${network.networkName} (${network.chainId})`);
      
      try {
        const result = await executeWithRetries(
          async () => {
            const provider = new ethers.JsonRpcProvider(network.rpcUrl);
            const wallet = new ethers.Wallet(privateKey, provider);
            
            const dleAbi = [
              "function getModuleAddress(bytes32 _moduleId) external view returns (address)",
              "function isModuleActive(bytes32 _moduleId) external view returns (bool)",
            ];
            
            const dle = new ethers.Contract(dleAddress, dleAbi, wallet);

            // Модули инициализируются только через governance
            console.log(`[DLE Modules] Модули инициализируются через governance предложения в сети ${network.chainId}`);

            // Получаем адрес модуля
            const moduleAddress = await dle.getModuleAddress(moduleId);
            
            if (moduleAddress === "0x0000000000000000000000000000000000000000") {
              throw new Error(`Модуль ${moduleType} не задеплоен`);
            }

            // Проверяем, что модуль не активен (если активен, значит уже инициализирован)
            const isActive = await dle.isModuleActive(moduleId);
            
            if (isActive) {
              console.log(`[DLE Modules] Модуль ${moduleType} уже активен в сети ${network.chainId}`);
              return {
                chainId: network.chainId,
                networkName: network.networkName,
                status: 'already_active',
                message: `Модуль ${moduleType} уже активен`
              };
            }

            // Для инициализации одного модуля нужно создать предложение
            // Но это сложно, поэтому пока просто отмечаем как требующий инициализации
            return {
              chainId: network.chainId,
              networkName: network.networkName,
              status: 'requires_governance',
              message: `Модуль ${moduleType} требует инициализации через governance`,
              moduleAddress: moduleAddress
            };
          },
          `Инициализация модуля ${moduleType} в сети ${network.networkName} (${network.chainId})`,
          maxRetries,
          retryDelay
        );

        results.push(result);

        if (result.status === 'not_deployed' || result.status === 'error') {
          allSuccessful = false;
        }

      } catch (error) {
        console.error(`[DLE Modules] Ошибка инициализации модуля ${moduleType} в сети ${network.chainId}:`, error.message);
        results.push({
          chainId: network.chainId,
          networkName: network.networkName,
          status: 'error',
          message: error.message,
          attempts: maxRetries
        });
        allSuccessful = false;
      }
    }

    res.json({
      success: true,
      data: {
        dleAddress: dleAddress,
        moduleType: moduleType,
        moduleId: moduleId,
        results: results,
        summary: {
          total: results.length,
          already_initialized: results.filter(r => r.status === 'already_initialized').length,
          already_active: results.filter(r => r.status === 'already_active').length,
          requires_governance: results.filter(r => r.status === 'requires_governance').length,
          not_deployed: results.filter(r => r.status === 'not_deployed').length,
          errors: results.filter(r => r.status === 'error').length,
          allSuccessful: allSuccessful
        },
        canProceed: allSuccessful,
        nextAction: allSuccessful ? 'deploy_next_module' : 'retry_initialization'
      }
    });

  } catch (error) {
    console.error('[DLE Modules] Ошибка инициализации модуля:', error);
    res.status(500).json({
      success: false,
      error: 'Ошибка инициализации модуля: ' + error.message
    });
  }
});

// Финальная проверка готовности всех компонентов
router.post('/final-deployment-check', async (req, res) => {
  try {
    const { dleAddress, chainIds } = req.body;
    
    if (!dleAddress || !chainIds || !Array.isArray(chainIds)) {
      return res.status(400).json({
        success: false,
        error: 'Адрес DLE и список chainIds обязательны'
      });
    }

    console.log(`[DLE Modules] Финальная проверка готовности DLE: ${dleAddress} в сетях: ${chainIds.join(', ')}`);

    // ID модулей для проверки
    const moduleIds = MODULE_TYPE_TO_ID;

    const results = [];
    let allComponentsReady = true;

    for (const chainId of chainIds) {
      console.log(`[DLE Modules] Финальная проверка в сети: ${chainId}`);
      
      try {
        const result = await executeWithRetries(
          async () => {
            const rpcUrl = await rpcProviderService.getRpcUrlByChainId(chainId);
            if (!rpcUrl) {
              throw new Error(`RPC URL не найден для сети ${chainId}`);
            }

            const provider = new ethers.JsonRpcProvider(rpcUrl);
            
            const dleAbi = [
              "function name() external view returns (string)",
              "function symbol() external view returns (string)",
,
              "function getModuleAddress(bytes32 _moduleId) external view returns (address)",
              "function isModuleActive(bytes32 _moduleId) external view returns (bool)"
            ];
            
            const dle = new ethers.Contract(dleAddress, dleAbi, provider);
            
            // Проверяем DLE контракт
            const dleCode = await provider.getCode(dleAddress);
            const dleDeployed = dleCode !== '0x';
            
            let dleInfo = null;
            if (dleDeployed) {
              try {
                // Проверяем что контракт развернут (код не пустой)
                const code = await provider.getCode(dleAddress);
                if (code === '0x' || code.length <= 2) {
                  throw new Error('Контракт не развернут');
                }
                const name = 'DLE'; // Используем фиксированное имя
                const symbol = 'DLE'; // Используем фиксированный символ
                dleInfo = { name, symbol };
              } catch (error) {
                console.log(`[DLE Modules] Ошибка получения информации о DLE в сети ${chainId}:`, error.message);
              }
            }

            // Проверяем модули
            const modulesStatus = {};
            let allModulesReady = true;

            for (const [moduleType, moduleId] of Object.entries(moduleIds)) {
              try {
                const moduleAddress = await dle.getModuleAddress(moduleId);
                const isActive = await dle.isModuleActive(moduleId);
                
                if (moduleAddress === "0x0000000000000000000000000000000000000000") {
                  modulesStatus[moduleType] = {
                    deployed: false,
                    active: false,
                    address: null
                  };
                  allModulesReady = false;
                } else {
                  const moduleCode = await provider.getCode(moduleAddress);
                  const moduleDeployed = moduleCode !== '0x';
                  
                  modulesStatus[moduleType] = {
                    deployed: moduleDeployed,
                    active: isActive,
                    address: moduleAddress
                  };
                  
                  if (!moduleDeployed || !isActive) {
                    allModulesReady = false;
                  }
                }
              } catch (error) {
                console.log(`[DLE Modules] Ошибка проверки модуля ${moduleType} в сети ${chainId}:`, error.message);
                modulesStatus[moduleType] = {
                  deployed: false,
                  active: false,
                  address: null,
                  error: error.message
                };
                allModulesReady = false;
              }
            }

            // Модули инициализируются только через governance
            const networkReady = dleDeployed && allModulesReady;
            
            return {
              chainId: chainId,
              status: networkReady ? 'ready' : 'not_ready',
              message: networkReady ? 'Все компоненты готовы' : 'Не все компоненты готовы',
              components: {
                dle: {
                  deployed: dleDeployed,
                  info: dleInfo
                },
                modules: modulesStatus,
                requiresGovernance: true
              }
            };
          },
          `Финальная проверка в сети ${chainId}`,
          1, // maxRetries
          30000 // retryDelay
        );

        results.push(result);

        if (result.status !== 'ready') {
          allComponentsReady = false;
        }

      } catch (error) {
        console.error(`[DLE Modules] Ошибка финальной проверки в сети ${chainId}:`, error.message);
        results.push({
          chainId: chainId,
          status: 'error',
          message: error.message,
          components: {},
          attempts: 1
        });
        allComponentsReady = false;
      }
    }

    res.json({
      success: true,
      data: {
        dleAddress: dleAddress,
        results: results,
        summary: {
          total: results.length,
          ready: results.filter(r => r.status === 'ready').length,
          not_ready: results.filter(r => r.status === 'not_ready').length,
          errors: results.filter(r => r.status === 'error').length,
          allComponentsReady: allComponentsReady
        },
        canShowCards: allComponentsReady,
        nextAction: allComponentsReady ? 'show_interface' : 'fix_issues'
      }
    });

  } catch (error) {
    console.error('[DLE Modules] Ошибка финальной проверки:', error);
    res.status(500).json({
      success: false,
      error: 'Ошибка финальной проверки: ' + error.message
    });
  }
});

// Получение статуса деплоя
router.post('/get-deployment-status', async (req, res) => {
  try {
    const { dleAddress } = req.body;
    
    if (!dleAddress) {
      return res.status(400).json({
        success: false,
        error: 'Адрес DLE обязателен'
      });
    }

    console.log(`[DLE Modules] Получение статуса деплоя для DLE: ${dleAddress}`);

    // Получаем поддерживаемые сети
    const supportedNetworks = await getSupportedNetworksFromDLE(dleAddress);
    
    if (supportedNetworks.length === 0) {
      return res.json({
        success: true,
        data: {
          status: 'not_started',
          currentStage: null,
          completedStages: [],
          failedStages: [],
          progress: 0,
          canShowCards: false,
          errors: ['Не найдены поддерживаемые сети для DLE'],
          nextAction: 'start_deployment'
        }
      });
    }

    // Проверяем статус каждого компонента
    const stages = [
      { name: 'deploy_dle', description: 'Деплой DLE контракта' },
      { name: 'verify_dle', description: 'Верификация DLE контракта' },
      { name: 'deploy_treasury', description: 'Деплой TreasuryModule' },
      { name: 'verify_treasury', description: 'Верификация TreasuryModule' },
      { name: 'initialize_treasury', description: 'Инициализация TreasuryModule' },
      { name: 'deploy_timelock', description: 'Деплой TimelockModule' },
      { name: 'verify_timelock', description: 'Верификация TimelockModule' },
      { name: 'initialize_timelock', description: 'Инициализация TimelockModule' },
      { name: 'deploy_reader', description: 'Деплой DLEReader' },
      { name: 'verify_reader', description: 'Верификация DLEReader' },
      { name: 'initialize_reader', description: 'Инициализация DLEReader' },
      { name: 'final_initialization', description: 'Финальная инициализация всех модулей' }
    ];

    const completedStages = [];
    const failedStages = [];
    let currentStage = null;
    let progress = 0;

    // Проверяем DLE контракт
    let dleDeployed = false;
    let dleVerified = false;
    
    try {
      const result = await executeWithRetries(
        async () => {
          const rpcUrl = await rpcProviderService.getRpcUrlByChainId(supportedNetworks[0].chainId);
          const provider = new ethers.JsonRpcProvider(rpcUrl);
          const dleCode = await provider.getCode(dleAddress);
          return dleCode !== '0x';
        },
        'Проверка деплоя DLE контракта',
        3,
        30000
      );
      
      dleDeployed = result;
      
      if (dleDeployed) {
        completedStages.push('deploy_dle');
        progress += 8.33; // 1/12 этапов
        
        // Проверяем верификацию (упрощенно - если контракт работает, считаем верифицированным)
        try {
          const verificationResult = await executeWithRetries(
            async () => {
              const rpcUrl = await rpcProviderService.getRpcUrlByChainId(supportedNetworks[0].chainId);
              const provider = new ethers.JsonRpcProvider(rpcUrl);
              // Простая проверка - если код контракта не пустой, считаем верифицированным
              const code = await provider.getCode(dleAddress);
              return code !== '0x' && code.length > 2;
            },
            'Проверка верификации DLE контракта',
            3,
            30000
          );
          
          dleVerified = verificationResult;
          if (dleVerified) {
            completedStages.push('verify_dle');
            progress += 8.33;
          }
        } catch (error) {
          failedStages.push('verify_dle');
        }
      } else {
        currentStage = 'deploy_dle';
      }
    } catch (error) {
      failedStages.push('deploy_dle');
      currentStage = 'deploy_dle';
    }

    // Если DLE не задеплоен, останавливаемся здесь
    if (!dleDeployed) {
      return res.json({
        success: true,
        data: {
          status: 'in_progress',
          currentStage: 'deploy_dle',
          completedStages: [],
          failedStages: failedStages,
          progress: 0,
          canShowCards: false,
          errors: ['DLE контракт не задеплоен'],
          nextAction: 'deploy_dle'
        }
      });
    }

    // Проверяем модули
    const moduleIds = MODULE_TYPE_TO_ID;

    const moduleStages = [
      { type: 'treasury', stages: ['deploy_treasury', 'verify_treasury', 'initialize_treasury'] },
      { type: 'timelock', stages: ['deploy_timelock', 'verify_timelock', 'initialize_timelock'] },
      { type: 'reader', stages: ['deploy_reader', 'verify_reader', 'initialize_reader'] }
    ];

    for (const moduleGroup of moduleStages) {
      try {
        const result = await executeWithRetries(
          async () => {
            const rpcUrl = await rpcProviderService.getRpcUrlByChainId(supportedNetworks[0].chainId);
            const provider = new ethers.JsonRpcProvider(rpcUrl);
            const dle = new ethers.Contract(dleAddress, [
              "function getModuleAddress(bytes32 _moduleId) external view returns (address)",
              "function isModuleActive(bytes32 _moduleId) external view returns (bool)"
            ], provider);

            const moduleAddress = await dle.getModuleAddress(moduleIds[moduleGroup.type]);
            const isActive = await dle.isModuleActive(moduleIds[moduleGroup.type]);

            return { moduleAddress, isActive };
          },
          `Проверка модуля ${moduleGroup.type}`,
          3,
          30000
        );

        const { moduleAddress, isActive } = result;

        if (moduleAddress !== "0x0000000000000000000000000000000000000000") {
          completedStages.push(moduleGroup.stages[0]); // deploy
          progress += 8.33;
          
          // Проверяем верификацию (упрощенно)
          try {
            const verificationResult = await executeWithRetries(
              async () => {
                const rpcUrl = await rpcProviderService.getRpcUrlByChainId(supportedNetworks[0].chainId);
                const provider = new ethers.JsonRpcProvider(rpcUrl);
                const moduleCode = await provider.getCode(moduleAddress);
                return moduleCode !== '0x';
              },
              `Проверка верификации модуля ${moduleGroup.type}`,
              3,
              30000
            );
            
            if (verificationResult) {
              completedStages.push(moduleGroup.stages[1]); // verify
              progress += 8.33;
            } else {
              failedStages.push(moduleGroup.stages[1]);
            }
          } catch (error) {
            failedStages.push(moduleGroup.stages[1]);
          }

          // Проверяем инициализацию
          if (isActive) {
            completedStages.push(moduleGroup.stages[2]); // initialize
            progress += 8.33;
          } else {
            if (!currentStage) currentStage = moduleGroup.stages[2];
          }
        } else {
          if (!currentStage) currentStage = moduleGroup.stages[0];
        }
      } catch (error) {
        if (!currentStage) currentStage = moduleGroup.stages[0];
      }
    }

    // Проверяем финальную инициализацию
    try {
      const result = await executeWithRetries(
        async () => {
          const rpcUrl = await rpcProviderService.getRpcUrlByChainId(supportedNetworks[0].chainId);
          const provider = new ethers.JsonRpcProvider(rpcUrl);
          const dle = new ethers.Contract(dleAddress, [
          ], provider);
          
          // Модули инициализируются только через governance
          return false;
        },
        'Проверка финальной инициализации модулей',
        3,
        30000
      );
      
      if (result) {
        completedStages.push('final_initialization');
        progress += 8.33;
      } else {
        if (!currentStage) currentStage = 'final_initialization';
      }
    } catch (error) {
      if (!currentStage) currentStage = 'final_initialization';
    }

    // Определяем общий статус
    let status = 'in_progress';
    if (progress >= 100) {
      status = 'completed';
      currentStage = null;
    } else if (failedStages.length > 0 && completedStages.length === 0) {
      status = 'failed';
    }

    res.json({
      success: true,
      data: {
        status: status,
        currentStage: currentStage,
        completedStages: completedStages,
        failedStages: failedStages,
        progress: Math.round(progress),
        canShowCards: status === 'completed',
        errors: failedStages.length > 0 ? [`Ошибки в этапах: ${failedStages.join(', ')}`] : [],
        nextAction: status === 'completed' ? 'none' : 
                   status === 'failed' ? 'restart_deployment' : 'continue_deployment'
      }
    });

  } catch (error) {
    console.error('[DLE Modules] Ошибка получения статуса деплоя:', error);
    res.status(500).json({
      success: false,
      error: 'Ошибка получения статуса деплоя: ' + error.message
    });
  }
});

module.exports = router;