import express from 'express';
import mysql from 'mysql2/promise';
import cors from 'cors';
import dotenv from 'dotenv';
import fs from 'fs';

dotenv.config();

const app = express();
app.use(cors());
app.use(express.json({ limit: '50mb' }));

// MySQL Pool Configuration
const pool = mysql.createPool({
  host: process.env.DB_HOST,
  user: process.env.DB_USER,
  password: process.env.DB_PASS,
  database: process.env.DB_NAME,
  port: parseInt(process.env.DB_PORT || '3306'),
  waitForConnections: true,
  connectionLimit: 10,
  queueLimit: 0
});

// Error Handler
const handleError = (res, err, label) => {
  console.error(`❌ [${label}] Error:`, err);
  res.status(500).json({ error: err.message });
};

// --- Global Constants ---
const CATEGORY_TABLE_MAP = {
  pc: 'asset_pc',
  server: 'asset_server',
  storage: 'asset_storage',
  network: 'asset_network',
  equipment: 'asset_equipment',
  officeSupplies: 'asset_office_supplies',
  survey: 'asset_survey',
  vip: 'asset_vip',
  swInternal: 'sw_internal',
  swExternal: 'sw_external',
  cloud: 'asset_cloud',
  users: 'user_master',
  swUsers: 'sw_assignment',
  logs: 'asset_history'
};

const ASSET_TABLES = [
  'asset_pc', 'asset_server', 'asset_storage', 'asset_network', 
  'asset_equipment', 'asset_office_supplies', 'asset_survey', 'asset_vip'
];

// --- API Endpoints ---

// 1. Generic Batch Save (Dynamic Table Detection)
app.post('/api/:table/batch', async (req, res) => {
  const { table } = req.params;
  const data = req.body;
  if (!Array.isArray(data)) return res.status(400).json({ error: 'Data must be an array' });

  let connection;
  try {
    connection = await pool.getConnection();
    await connection.beginTransaction();

    const [columns] = await connection.query(`DESCRIBE ${table}`);
    const validFields = columns.map(c => c.Field);

    await connection.query(`DELETE FROM ${table}`);

    if (data.length > 0) {
        const placeholders = validFields.map(() => '?').join(', ');
        const sql = `INSERT INTO ${table} (${validFields.join(', ')}) VALUES (${placeholders})`;
        
        for (const item of data) {
            const values = validFields.map(field => {
                const val = item[field];
                return val === undefined ? null : val;
            });
            await connection.query(sql, values);
        }
    }

    await connection.commit();
    res.json({ success: true, count: data.length });
  } catch (err) {
    if (connection) await connection.rollback();
    handleError(res, err, 'BATCH SAVE');
  } finally {
    if (connection) connection.release();
  }
});

// 2. Get All Assets (Integrated Master Data from Normalized V3 Schema)
app.get('/api/assets/master', async (req, res) => {
  try {
    const connection = await pool.getConnection();

    const masterData = {
      pc: [], server: [], storage: [], network: [],
      equipment: [], officeSupplies: [], survey: [], vip: [], pcParts: [],
      swInternal: [], swExternal: [], swUsers: [], users: [], logs: []
    };

    const [rows] = await connection.query(`
      SELECT 
        c.*, 
        s.hw_status, s.model_name, s.mainboard, s.os, s.cpu, s.ram, s.gpu, 
        s.monitoring, s.price, s.monitor_inch, s.serial_num,
        l.location, l.location_detail, l.location_photo, l.loc_x, l.loc_y,
        n.ip_address, n.mac_address, n.remote_tool, n.remote_id, n.remote_pw,
        (SELECT CONCAT(capacity, unit) FROM asset_volume WHERE asset_id = c.id AND disk_type = 'SSD' AND slot_no = 1 LIMIT 1) as ssd_1,
        (SELECT CONCAT(capacity, unit) FROM asset_volume WHERE asset_id = c.id AND disk_type = 'SSD' AND slot_no = 2 LIMIT 1) as ssd_2,
        (SELECT CONCAT(capacity, unit) FROM asset_volume WHERE asset_id = c.id AND disk_type = 'HDD' AND slot_no = 1 LIMIT 1) as hdd_1,
        (SELECT CONCAT(capacity, unit) FROM asset_volume WHERE asset_id = c.id AND disk_type = 'HDD' AND slot_no = 2 LIMIT 1) as hdd_2,
        (SELECT GROUP_CONCAT(CONCAT(disk_type, ': ', capacity, unit) SEPARATOR ', ') FROM asset_volume WHERE asset_id = c.id) as volume_summary
      FROM asset_core c
      LEFT JOIN asset_spec s ON c.id = s.asset_id
      LEFT JOIN asset_location l ON l.id = (
        SELECT id FROM asset_location 
        WHERE asset_id = c.id AND is_active = 1 
        ORDER BY created_at DESC LIMIT 1
      )
      LEFT JOIN asset_network n ON n.id = (
        SELECT id FROM asset_network 
        WHERE asset_id = c.id AND is_active = 1 
        ORDER BY created_at DESC LIMIT 1
      )
    `);

    const catMap = {
      'PC': 'pc', '서버': 'server', '저장매체': 'storage', '네트워크': 'network',
      '업무지원장비': 'equipment', '사무가구': 'officeSupplies', '공간정보장비': 'survey',
      '내빈/외빈': 'vip', 'PC부품': 'pcParts'
    };

    rows.forEach(row => {
      const key = catMap[row.category] || 'pc';
      masterData[key].push(row);
    });

    const [swInternal] = await connection.query('SELECT * FROM asset_software_perpetual');
    const [swExternal] = await connection.query('SELECT * FROM asset_software_subscription');
    const [swUsers] = await connection.query('SELECT * FROM asset_software_assignment');
    const [users] = await connection.query('SELECT * FROM system_users');
    const [logs] = await connection.query('SELECT * FROM asset_history ORDER BY created_at DESC');
    
    masterData.swInternal = swInternal;
    masterData.swExternal = swExternal;
    masterData.swUsers = swUsers;
    masterData.users = users;
    masterData.logs = logs;

    connection.release();
    res.json(masterData);
  } catch (err) {
    handleError(res, err, 'MASTER DATA');
  }
});

// 3. Asset Save (Surgical Split to Normalized V3 Tables)
app.post('/api/asset/:category/save', async (req, res) => {
  const asset = req.body;
  let connection;
  try {
    connection = await pool.getConnection();
    await connection.beginTransaction();

    // 3.1 asset_core
    const coreFields = ['id', 'asset_code', 'category', 'asset_type', 'current_role', 'asset_purpose', 'service_type', 'purchase_corp', 'purchase_date', 'purchase_amount', 'purchase_vendor', 'approval_document', 'memo', 'manager_primary', 'manager_secondary', 'current_dept', 'previous_dept', 'user_current', 'previous_user', 'emp_no', 'user_position'];
    const coreData = {};
    coreFields.forEach(f => { if (asset[f] !== undefined) coreData[f] = asset[f]; });
    const coreKeys = Object.keys(coreData);
    const coreSql = `INSERT INTO asset_core (${coreKeys.join(', ')}) VALUES (${coreKeys.map(() => '?').join(', ')}) ON DUPLICATE KEY UPDATE ${coreKeys.map(k => `${k} = VALUES(${k})`).join(', ')}`;
    await connection.query(coreSql, Object.values(coreData));

    // 3.2 asset_spec
    const specFields = ['hw_status', 'model_name', 'mainboard', 'os', 'cpu', 'ram', 'gpu', 'monitoring', 'price', 'monitor_inch', 'serial_num'];
    const specData = { asset_id: asset.id };
    specFields.forEach(f => { if (asset[f] !== undefined) specData[f] = asset[f]; });
    const specKeys = Object.keys(specData);
    const [specExists] = await connection.query('SELECT id FROM asset_spec WHERE asset_id = ?', [asset.id]);
    if (specExists.length > 0) {
        const updateSql = `UPDATE asset_spec SET ${specKeys.filter(k => k !== 'asset_id').map(k => `${k} = ?`).join(', ')} WHERE asset_id = ?`;
        await connection.query(updateSql, [...specKeys.filter(k => k !== 'asset_id').map(k => specData[k]), asset.id]);
    } else {
        await connection.query(`INSERT INTO asset_spec (${specKeys.join(', ')}) VALUES (${specKeys.map(() => '?').join(', ')})`, Object.values(specData));
    }

    // 3.3 asset_volume (Legacy Parser)
    const parseCapacity = (str) => {
        if (!str || str.trim() === '' || str.toLowerCase() === 'null') return null;
        const match = str.match(/(\d+(?:\.\d+)?)\s*([GT]B)?/i);
        if (match) return { value: parseFloat(match[1]), unit: (match[2] || 'GB').toUpperCase() };
        return null;
    };
    const storages = [
        { val: asset.ssd_1, type: 'SSD', slot: 1 },
        { val: asset.ssd_2, type: 'SSD', slot: 2 },
        { val: asset.hdd_1, type: 'HDD', slot: 1 },
        { val: asset.hdd_2, type: 'HDD', slot: 2 }
    ];
    await connection.query('DELETE FROM asset_volume WHERE asset_id = ?', [asset.id]);
    for (const s of storages) {
        const parsed = parseCapacity(s.val);
        if (parsed) {
            await connection.query('INSERT INTO asset_volume (asset_id, disk_type, capacity, unit, slot_no) VALUES (?, ?, ?, ?, ?)', 
                [asset.id, s.type, parsed.value, parsed.unit, s.slot]);
        }
    }

    // 3.4 asset_location
    if (asset.location || asset.location_detail) {
        const [locActive] = await connection.query('SELECT * FROM asset_location WHERE asset_id = ? AND is_active = 1', [asset.id]);
        const isChanged = locActive.length === 0 || locActive[0].location !== asset.location || locActive[0].location_detail !== asset.location_detail || locActive[0].loc_x !== asset.loc_x || locActive[0].loc_y !== asset.loc_y;
        if (isChanged) {
            await connection.query('UPDATE asset_location SET is_active = 0, deactivated_at = NOW() WHERE asset_id = ? AND is_active = 1', [asset.id]);
            await connection.query(`INSERT INTO asset_location (asset_id, location, location_detail, location_photo, loc_x, loc_y, is_active) VALUES (?, ?, ?, ?, ?, ?, 1)`, 
                [asset.id, asset.location, asset.location_detail, asset.location_photo, asset.loc_x, asset.loc_y]);
        }
    }

    // 3.5 asset_network
    if (asset.ip_address || asset.mac_address || asset.remote_tool) {
        const [netActive] = await connection.query('SELECT * FROM asset_network WHERE asset_id = ? AND is_active = 1', [asset.id]);
        const isChanged = netActive.length === 0 || netActive[0].ip_address !== asset.ip_address || netActive[0].mac_address !== asset.mac_address || netActive[0].remote_tool !== asset.remote_tool || netActive[0].remote_id !== asset.remote_id || netActive[0].remote_pw !== asset.remote_pw;
        if (isChanged) {
            await connection.query('UPDATE asset_network SET is_active = 0, deactivated_at = NOW() WHERE asset_id = ? AND is_active = 1', [asset.id]);
            await connection.query(`INSERT INTO asset_network (asset_id, ip_address, mac_address, remote_tool, remote_id, remote_pw, is_active) VALUES (?, ?, ?, ?, ?, ?, 1)`, 
                [asset.id, asset.ip_address, asset.mac_address, asset.remote_tool, asset.remote_id, asset.remote_pw]);
        }
    }

    await connection.commit();
    console.log(`💾 [V3 ASSET SAVE] ID: ${asset.id}`);
    res.json({ success: true });
  } catch (err) {
    if (connection) await connection.rollback();
    handleError(res, err, 'ASSET SAVE V3');
  } finally {
    if (connection) connection.release();
  }
});

// 4. Asset Delete
app.delete('/api/asset/:category/:id', async (req, res) => {
  const { category, id } = req.params;
  
  // Define mapping for which base table handles the delete
  const deleteTableMap = {
    pc: 'asset_core',
    server: 'asset_core',
    storage: 'asset_core',
    network: 'asset_core',
    equipment: 'asset_core',
    officeSupplies: 'asset_core',
    survey: 'asset_core',
    vip: 'asset_core',
    pcParts: 'asset_core',
    swInternal: 'asset_software_perpetual',
    swExternal: 'asset_software_subscription',
    swUsers: 'asset_software_assignment',
    users: 'system_users'
  };

  const table = deleteTableMap[category];
  
  if (!table) return res.status(400).json({ error: 'Invalid category for deletion' });
  
  try {
    const connection = await pool.getConnection();
    // For asset_core, ON DELETE CASCADE will handle spec, location, network, volume
    await connection.query(`DELETE FROM ${table} WHERE id = ?`, [id]);
    connection.release();
    console.log(`🗑️ [ASSET DELETE] Category: ${category}, ID: ${id}`);
    res.json({ success: true });
  } catch (err) { 
    handleError(res, err, 'ASSET DELETE'); 
  }
});

// 5. Generate Next Asset Code
app.get('/api/generate-asset-code', async (req, res) => {
  const { prefix, purchaseDate } = req.query;
  if (!prefix) return res.status(400).json({ error: 'Prefix is required' });
  try {
    const connection = await pool.getConnection();
    const datePart = purchaseDate ? purchaseDate.toString().replace(/-/g, '').substring(0, 6) : '';
    const searchPattern = datePart ? `${prefix}-${datePart}-%` : `${prefix}-%`;
    let maxNum = 0;
    for (const table of ASSET_TABLES) {
        try {
          const [rows] = await connection.query(`SELECT asset_code FROM ${table} WHERE asset_code LIKE ?`, [searchPattern]);
          rows.forEach(row => {
            const parts = row.asset_code.split('-');
            const num = parseInt(parts[parts.length - 1]);
            if (!isNaN(num) && num > maxNum) maxNum = num;
          });
        } catch (err) {}
    }
    const nextNum = maxNum + 1;
    const nextCode = datePart ? `${prefix}-${datePart}-${String(nextNum).padStart(4, '0')}` : `${prefix}-${String(nextNum).padStart(4, '0')}`;
    connection.release();
    res.json({ nextCode });
  } catch (err) { handleError(res, err, 'GENERATE CODE'); }
});

// 6. Map Config API
app.get('/api/maps', (req, res) => {
  try {
    if (!fs.existsSync('map_config.json')) return res.json({});
    const data = fs.readFileSync('map_config.json', 'utf8');
    res.json(JSON.parse(data || '{}'));
  } catch (err) { handleError(res, err, 'GET MAPS'); }
});

app.post('/api/maps/save', (req, res) => {
  try {
    const { path, boxes } = req.body;
    if (!path) return res.status(400).json({ error: 'Path is required' });
    let config = {};
    if (fs.existsSync('map_config.json')) config = JSON.parse(fs.readFileSync('map_config.json', 'utf8') || '{}');
    config[path] = boxes;
    fs.writeFileSync('map_config.json', JSON.stringify(config, null, 2));
    res.json({ success: true });
  } catch (err) { handleError(res, err, 'SAVE MAPS'); }
});

app.listen(3000, '0.0.0.0', () => {
  console.log('📡 ITAM BACKEND SERVER RUNNING ON PORT 3000 (V3 Normalized)');
});