plugins/chahua-web-store/setup.js

/**
 *  Chahua Web Store Database Plugin (v1.2.0)
 * สร้างฐานข้อมูล PostgreSQL แบบโมดูลาร์สำหรับ Chahua Web Store
 *  Chahua Development Thailand
 *  CEO: Saharath C.
 *  รองรับ Drag & Drop และการรันโดยตรง
 */

const { Client } = require('pg');
const fs = require('fs');
const path = require('path');

// Import database tools
const { restoreDb, dumpDb } = require('../../tools/db-tools');

// Import modules
const enumsModule = require('./modules/01-enums');
const coreTablesModule = require('./modules/02-core-tables');
const paymentTablesModule = require('./modules/03-payment-tables');
const forumTablesModule = require('./modules/04-forum-tables');
const pluginSubmissionTablesModule = require('./modules/05-plugin-submission-tables');
const dashboardTablesModule = require('./modules/06-dashboard-tables');
const bankTransferTablesModule = require('./modules/07-bank-transfer-tables');
const functionsTriggersModule = require('./modules/08-functions-triggers');
const indexesViewsModule = require('./modules/09-indexes-views');

// Plugin metadata
const PLUGIN_INFO = {
    name: ' Chahua Web Store',
    version: 'v1.2.1',
    description: 'Complete database schema for Chahua Web Store platform with Drag & Drop support and SQL Dump',
    author: 'Chahua Development Thailand',
    supportedDatabases: ['postgresql'],
    features: ['drag-drop', 'direct-execution', 'modular-setup', 'sql-dump'],
    ui: {
        allowDragDrop: true,
        allowDirectRun: true,
        allowSQLDump: true,
        supportedFileTypes: ['.sql', '.json']
    }
};

/**
 * จัดการไฟล์ที่ลากมาวาง (Drag & Drop Handler)
 * @param {string|Array} filePaths - เส้นทางไฟล์หรือรายการไฟล์
 * @param {Object} dbConfig - การตั้งค่าฐานข้อมูล
 * @returns {Promise<Object>} - ผลลัพธ์การประมวลผล
 */
async function handleDroppedFiles(filePaths, dbConfig) {
    console.log(' Processing dropped files...');

    if (!Array.isArray(filePaths)) {
        filePaths = [filePaths];
    }

    const results = {
        processed: [],
        errors: [],
        summary: {
            total: filePaths.length,
            success: 0,
            failed: 0
        }
    };

    for (const filePath of filePaths) {
        try {
            console.log(` Processing: ${path.basename(filePath)}`);

            const fileExtension = path.extname(filePath).toLowerCase();
            const fileName = path.basename(filePath);

            if (fileExtension === '.sql') {
                const result = await processSQLFile(filePath, dbConfig);
                results.processed.push({
                    file: fileName,
                    type: 'sql',
                    status: 'success',
                    result: result
                });
                results.summary.success++;
            } else if (fileExtension === '.json') {
                const result = await processJSONFile(filePath, dbConfig);
                results.processed.push({
                    file: fileName,
                    type: 'json',
                    status: 'success',
                    result: result
                });
                results.summary.success++;
            } else {
                throw new Error(`Unsupported file type: ${fileExtension}`);
            }

        } catch (error) {
            console.error(` Error processing ${filePath}:`, error.message);
            results.errors.push({
                file: path.basename(filePath),
                error: error.message
            });
            results.summary.failed++;
        }
    }

    console.log(` Drag & Drop processing completed: ${results.summary.success} success, ${results.summary.failed} failed`);
    return results;
}

/**
 * ประมวลผลไฟล์ SQL
 * @param {string} filePath - เส้นทางไฟล์ SQL
 * @param {Object} dbConfig - การตั้งค่าฐานข้อมูล
 * @returns {Promise<Object>} - ผลลัพธ์การรัน SQL
 */
async function processSQLFile(filePath, dbConfig) {
    const sqlContent = fs.readFileSync(filePath, 'utf8');

    if (!sqlContent.trim()) {
        throw new Error('SQL file is empty');
    }

    const client = new Client(dbConfig);

    try {
        await client.connect();
        console.log(` Executing SQL from: ${path.basename(filePath)}`);

        // แยก SQL statements (หากมีหลายคำสั่ง)
        const statements = sqlContent
            .split(';')
            .map(s => s.trim())
            .filter(s => s.length > 0);

        const results = [];

        for (const statement of statements) {
            const result = await client.query(statement);
            results.push({
                command: statement.substring(0, 50) + '...',
                rowsAffected: result.rowCount || 0
            });
        }

        return {
            statements: results.length,
            totalRows: results.reduce((sum, r) => sum + r.rowsAffected, 0)
        };

    } finally {
        await client.end();
    }
}

/**
 * ประมวลผลไฟล์ JSON (สำหรับข้อมูลหรือ config)
 * @param {string} filePath - เส้นทางไฟล์ JSON
 * @param {Object} dbConfig - การตั้งค่าฐานข้อมูล
 * @returns {Promise<Object>} - ผลลัพธ์การประมวลผล JSON
 */
async function processJSONFile(filePath, dbConfig) {
    const jsonContent = fs.readFileSync(filePath, 'utf8');
    const data = JSON.parse(jsonContent);

    const fileName = path.basename(filePath, '.json');

    // ถ้าเป็นไฟล์ data
    if (fileName.includes('data') || fileName === 'plugins' || fileName === 'users') {
        return await insertJSONData(data, dbConfig, fileName);
    }

    // ถ้าเป็นไฟล์ config
    return {
        type: 'config',
        keys: Object.keys(data),
        message: 'JSON configuration loaded'
    };
}

/**
 * แทรกข้อมูลจาก JSON เข้าฐานข้อมูล
 * @param {Object} data - ข้อมูล JSON
 * @param {Object} dbConfig - การตั้งค่าฐานข้อมูล
 * @param {string} tableName - ชื่อตาราง (optional)
 * @returns {Promise<Object>} - ผลลัพธ์การแทรกข้อมูล
 */
async function insertJSONData(data, dbConfig, tableName = null) {
    const client = new Client(dbConfig);

    try {
        await client.connect();

        if (Array.isArray(data)) {
            // ถ้า data เป็น array ให้แทรกทีละตัว
            let insertCount = 0;

            for (const item of data) {
                if (typeof item === 'object' && item !== null) {
                    const table = tableName || inferTableName(item);

                    // แปลง features และ tags array เป็น JSON string ถ้าจำเป็น
                    const processedItem = { ...item };
                    if (Array.isArray(processedItem.features)) {
                        processedItem.features = JSON.stringify(processedItem.features);
                    }
                    if (Array.isArray(processedItem.tags)) {
                        processedItem.tags = JSON.stringify(processedItem.tags);
                    }

                    const columns = Object.keys(processedItem);
                    const values = Object.values(processedItem);
                    const placeholders = values.map((_, i) => `$${i + 1}`).join(', ');

                    const insertSQL = `INSERT INTO ${table} (${columns.join(', ')}) VALUES (${placeholders}) ON CONFLICT (id) DO UPDATE SET ${columns.filter(c => c !== 'id').map(c => `${c} = EXCLUDED.${c}`).join(', ')}`;

                    try {
                        const result = await client.query(insertSQL, values);
                        insertCount++;
                    } catch (err) {
                        console.warn(`Warning: Could not insert into ${table}:`, err.message);
                    }
                }
            }

            return {
                type: 'data_insert',
                records: data.length,
                inserted: insertCount
            };
        } else if (typeof data === 'object') {
            // ถ้า data เป็น object ให้ดูว่ามี key ที่เป็น array หรือไม่
            const results = {};

            for (const [key, value] of Object.entries(data)) {
                if (Array.isArray(value)) {
                    results[key] = await insertJSONData(value, { client }, key);
                }
            }

            return {
                type: 'multi_table_insert',
                tables: results
            };
        }

        return {
            type: 'unknown',
            message: 'JSON structure not recognized'
        };

    } finally {
        await client.end();
    }
}

/**
 * คาดเดาชื่อตารางจาก object properties
 * @param {Object} item - object ที่ต้องการคาดเดาชื่อตาราง
 * @returns {string} - ชื่อตารางที่คาดเดา
 */
function inferTableName(item) {
    const keys = Object.keys(item);

    // ลองหาชื่อตารางจาก key patterns
    if (keys.includes('user_id') || keys.includes('username')) return 'users';
    if (keys.includes('plugin_id') || keys.includes('plugin_name')) return 'plugins';
    if (keys.includes('product_id') || keys.includes('product_name')) return 'products';
    if (keys.includes('category_id') || keys.includes('category_name')) return 'categories';
    if (keys.includes('order_id') || keys.includes('order_status')) return 'orders';

    return 'data_import'; // fallback table name
}

/**
 *  Dump ข้อมูลจากฐานข้อมูลออกเป็น SQL ไฟล์
 * @param {Object} dbConfig - การตั้งค่าฐานข้อมูล
 * @param {string} tableName - ชื่อตารางเฉพาะ (optional)
 * @returns {Promise<Object>} - ผลลัพธ์การ dump
 */
async function dumpDatabaseToSQL(dbConfig, tableName = null) {
    console.log(' Dumping database to SQL files...');
    console.log(` ${PLUGIN_INFO.name} ${PLUGIN_INFO.version}`);
    console.log(` ${PLUGIN_INFO.author}`);

    const client = new Client(dbConfig);

    try {
        await client.connect();
        console.log(` Connected to database for dumping...`);

        if (tableName) {
            // Single table dump not supported
            return {
                success: false,
                error: 'Table dump functionality not available'
            };
        } else {
            // Full database dump not supported
            return {
                success: false,
                error: 'SQL dump functionality not available'
            };
        }

    } catch (error) {
        console.error(' Database dump failed:', error.message);
        throw error;
    } finally {
        await client.end();
        console.log(' Disconnected from database.');
    }
}

/**
 * รันปลั๊กอินโดยตรง (Direct Run)
 * @param {Object} config - การตั้งค่าการรัน
 * @returns {Promise<Object>} - ผลลัพธ์การรัน
 */
async function runPlugin(config = null) {
    console.log(' Running Chahua Web Store Plugin directly...');
    console.log(` ${PLUGIN_INFO.name} ${PLUGIN_INFO.version}`);
    console.log(` ${PLUGIN_INFO.author}`);

    try {
        // ถ้าไม่มี config ให้ใช้ค่า default
        if (!config) {
            config = {
                dbConfig: {
                    host: 'localhost',
                    port: 5432,
                    database: 'postgres',
                    user: 'postgres',
                    password: 'password'
                },
                targetDatabase: 'chahua_web_store'
            };
        }

        // สร้างฐานข้อมูล
        await createDatabase(config.dbConfig, config.targetDatabase);

        // สร้างโครงสร้าง
        const result = await setupDatabaseStructure(config);

        console.log(' Plugin execution completed successfully!');

        return {
            ...result,
            pluginInfo: PLUGIN_INFO,
            timestamp: new Date().toISOString()
        };

    } catch (error) {
        console.error(' Plugin execution failed:', error.message);
        throw error;
    }
}
async function createDatabase(dbConfig, targetDatabase) {
    // 1. สร้าง client เพื่อเชื่อมต่อไปยังฐานข้อมูลกลาง (template1 มีอยู่ทุกเครื่อง PostgreSQL)
    const maintenanceClient = new Client({
        ...dbConfig,
        database: 'template1' // ใช้ 'template1' เป็นมาตรฐาน เพราะมีอยู่ทุกเครื่อง PostgreSQL
    });

    try {
        await maintenanceClient.connect();
        console.log(' Connected to PostgreSQL server for maintenance...');

        // 2. ตรวจสอบว่าฐานข้อมูลเป้าหมายมีอยู่หรือไม่
        const checkDbResult = await maintenanceClient.query('SELECT 1 FROM pg_database WHERE datname = $1', [targetDatabase]);

        if (checkDbResult.rows.length > 0) {
            console.log(` Terminating existing connections to "${targetDatabase}"...`);
            // ยกเลิกการเชื่อมต่อทั้งหมดที่อาจค้างอยู่
            await maintenanceClient.query(`
                SELECT pg_terminate_backend(pid) FROM pg_stat_activity
                WHERE datname = $1 AND pid <> pg_backend_pid()`, [targetDatabase]);

            console.log(` Dropping old database "${targetDatabase}"...`);
            // ลบฐานข้อมูลเก่าทิ้ง
            await maintenanceClient.query(`DROP DATABASE "${targetDatabase}"`);
        }

        // 3. สร้างฐานข้อมูลขึ้นมาใหม่
        console.log(` Creating new database "${targetDatabase}"...`);

        //  ตรวจสอบ OS และเลือก locale ที่เหมาะสม
        const os = require('os');
        const isWindows = os.platform() === 'win32';

        let createDbQuery;
        if (isWindows) {
            // สำหรับ Windows ให้ตรวจสอบ available locales ก่อน
            console.log(' Detected Windows - checking available locales...');

            try {
                // ตรวจสอบว่ามี locale ไหนใช้ได้บ้าง
                const localesResult = await maintenanceClient.query(`
                    SELECT datcollate, datctype FROM pg_database WHERE datname = 'template1'
                `);

                const templateLocale = localesResult.rows[0];
                console.log(` Template locale: ${templateLocale.datcollate} / ${templateLocale.datctype}`);

                // ใช้ locale จาก template1 หรือใช้ค่า default
                if (templateLocale.datcollate && templateLocale.datctype) {
                    createDbQuery = `
                        CREATE DATABASE "${targetDatabase}"
                        WITH ENCODING 'UTF8'
                        LC_COLLATE '${templateLocale.datcollate}'
                        LC_CTYPE   '${templateLocale.datctype}'
                        TEMPLATE template0
                    `;
                } else {
                    // ใช้แบบไม่ระบุ locale
                    createDbQuery = `
                        CREATE DATABASE "${targetDatabase}"
                        WITH ENCODING 'UTF8'
                        TEMPLATE template0
                    `;
                }
            } catch (localeError) {
                console.log(' Could not detect locale, using minimal setup');
                createDbQuery = `
                    CREATE DATABASE "${targetDatabase}"
                    WITH ENCODING 'UTF8'
                    TEMPLATE template0
                `;
            }
        } else {
            // สำหรับ Linux/Unix ใช้ C.UTF-8
            console.log(' Detected Unix/Linux - using C.UTF-8 locale');
            createDbQuery = `
                CREATE DATABASE "${targetDatabase}"
                WITH ENCODING 'UTF8'
                LC_COLLATE 'C.UTF-8'
                LC_CTYPE   'C.UTF-8'
                TEMPLATE template0
            `;
        }

        console.log(' Executing database creation query...');
        await maintenanceClient.query(createDbQuery);
        console.log(` Database "${targetDatabase}" has been successfully created.`);

    } catch (err) {
        console.error(' Error during database creation:', err.message);
        throw err;
    } finally {
        // 4. ปิดการเชื่อมต่อกับฐานข้อมูลกลางเสมอ
        await maintenanceClient.end();
        console.log(' Disconnected from maintenance database.');
    }
}

/**
 * ติดตั้งโครงสร้างและข้อมูลทั้งหมดลงในฐานข้อมูลที่สร้างใหม่
 */
async function setupDatabaseStructure(config = null) {
    const dbConfig = config?.dbConfig;
    const targetDatabase = config?.targetDatabase;

    // *** สร้าง client ใหม่เพื่อเชื่อมต่อไปยังฐานข้อมูลเป้าหมายโดยตรง ***
    const appClient = new Client({
        ...dbConfig,
        database: targetDatabase
    });

    try {
        await appClient.connect();
        console.log(` Connected to target database "${targetDatabase}" to build structure...`);

        // --- รันสคริปต์ทั้งหมดตามลำดับ ---
        console.log('\n Starting structure setup...');
        await enumsModule.createEnums(appClient);
        await coreTablesModule.createCoreTables(appClient);
        await paymentTablesModule.createPaymentTables(appClient);
        await forumTablesModule.createForumTables(appClient);
        await pluginSubmissionTablesModule.createPluginSubmissionTables(appClient);
        await dashboardTablesModule.createDashboardTables(appClient);
        await bankTransferTablesModule.createBankTransferTables(appClient);
        await functionsTriggersModule.createFunctionsAndTriggers(appClient);

        // ต้องส่ง existingTables ไปให้ createTriggers และ createIndexes
        const tablesResult = await appClient.query("SELECT tablename FROM pg_tables WHERE schemaname = 'public'");
        const existingTables = tablesResult.rows.map(row => row.tablename);

        await functionsTriggersModule.createTriggers(appClient, existingTables);
        await indexesViewsModule.createIndexes(appClient, existingTables);
        await indexesViewsModule.createViews(appClient);

        console.log(' Database setup completed successfully!');

        return {
            success: true,
            summary: {
                totalTables: existingTables.length,
                pluginName: 'Chahua Web Store'
            }
        };

    } catch (err) {
        console.error(' Error setting up database structure:', err.message);
        throw err;
    } finally {
        await appClient.end();
        console.log(` Disconnected from "${targetDatabase}".`);
    }
}

/**
 * Import database from file using db-tools
 * @param {string} filePath - Path to backup file (.sql, .dump, .backup)
 * @param {Object} config - Database configuration
 */
async function importFromFile(filePath, config = {}) {
    const cfg = {
        host: config.host || process.env.DB_HOST || '127.0.0.1',
        port: config.port || process.env.DB_PORT || 5432,
        user: config.user || process.env.DB_USER || 'postgres',
        password: config.password || process.env.DB_PASS || '',
        database: config.database || process.env.DB_NAME || 'chahua_web_store',
    };

    console.log(' Importing database from:', filePath);
    await restoreDb(cfg, filePath);
    console.log(' Database import completed');
}

/**
 * Export database to file using db-tools
 * @param {string} outFile - Output file path
 * @param {string} format - Export format ('custom' or 'sql')
 * @param {Object} config - Database configuration
 */
async function exportToFile(outFile, format = 'custom', config = {}) {
    const cfg = {
        host: config.host || process.env.DB_HOST || '127.0.0.1',
        port: config.port || process.env.DB_PORT || 5432,
        user: config.user || process.env.DB_USER || 'postgres',
        password: config.password || process.env.DB_PASS || '',
        database: config.database || process.env.DB_NAME || 'chahua_web_store',
    };

    console.log(' Exporting database to:', outFile);
    await dumpDb(cfg, outFile, { format });
    console.log(' Database export completed');
}

module.exports = {
    PLUGIN_INFO,
    createDatabase,
    setupDatabaseStructure,
    handleDroppedFiles,
    processSQLFile,
    processJSONFile,
    dumpDatabaseToSQL,
    runPlugin,
    importFromFile,
    exportToFile
};