#!/usr/bin/env node

/**
 * Streamingle Camera Plugin Build Script
 * StreamDock 플러그인 폴더에 자동 복사 기능 포함
 */

const fs = require('fs');
const path = require('path');

// 설정
const PLUGIN_NAME = 'com.mirabox.streamingle.sdPlugin';
const STREAMDOCK_PLUGINS_PATH = 'C:\\Users\\qscft\\AppData\\Roaming\\HotSpot\\StreamDock\\plugins';
const CURRENT_DIR = __dirname;
    
// 색상 출력 함수
function log(message, color = 'white') {
    const colors = {
        red: '\x1b[31m',
        green: '\x1b[32m',
        yellow: '\x1b[33m',
        blue: '\x1b[34m',
        magenta: '\x1b[35m',
        cyan: '\x1b[36m',
        white: '\x1b[37m',
        reset: '\x1b[0m'
    };
    console.log(`${colors[color]}${message}${colors.reset}`);
}

// 디렉토리 복사 함수 (제외할 파일/폴더 필터링 포함)
function copyDirectory(src, dest) {
    // 제외할 파일/폴더 목록
    const excludePatterns = [
        'dist',
        'dist-dev', 
        'node_modules',
        '.git',
        '.gitignore',
        'build.js',
        'build.log',
        'README.md'
        // package.json과 package-lock.json은 제외하지 않음 (MiraBox StreamDock에서 필요할 수 있음)
    ];

    if (!fs.existsSync(dest)) {
        fs.mkdirSync(dest, { recursive: true });
    }
        
    const entries = fs.readdirSync(src, { withFileTypes: true });
        
    for (const entry of entries) {
        // 제외할 파일/폴더 체크
        if (excludePatterns.includes(entry.name)) {
            console.log(`⏭️ 제외: ${entry.name}`);
            continue;
        }

        const srcPath = path.join(src, entry.name);
        const destPath = path.join(dest, entry.name);
            
        if (entry.isDirectory()) {
            copyDirectory(srcPath, destPath);
            } else {
            fs.copyFileSync(srcPath, destPath);
            }
    }
    }
    
    // 디렉토리 삭제 함수
function removeDirectory(dirPath) {
        if (fs.existsSync(dirPath)) {
        fs.rmSync(dirPath, { recursive: true, force: true });
        }
    }
    
// 빌드 함수 - StreamDock 플러그인 폴더에 직접 빌드
function build() {
    log('🔨 Streamingle Camera Plugin 빌드 시작...', 'cyan');
    
    const buildDir = path.join(STREAMDOCK_PLUGINS_PATH, PLUGIN_NAME);
    const pluginDir = CURRENT_DIR;
            
    // StreamDock 플러그인 폴더 확인
    if (!fs.existsSync(STREAMDOCK_PLUGINS_PATH)) {
        log('❌ StreamDock 플러그인 폴더를 찾을 수 없습니다', 'red');
        log(`📁 예상 경로: ${STREAMDOCK_PLUGINS_PATH}`, 'yellow');
        return false;
            }
            
    // 기존 플러그인 삭제
    if (fs.existsSync(buildDir)) {
        removeDirectory(buildDir);
        log('🗑️ 기존 플러그인 삭제 완료', 'yellow');
    }
    
    // 빌드 폴더 생성
    fs.mkdirSync(buildDir, { recursive: true });
    
    // 플러그인 폴더 복사
    if (fs.existsSync(pluginDir)) {
        copyDirectory(pluginDir, buildDir);
        log('✅ 플러그인 파일 복사 완료', 'green');
                    } else {
        log('❌ 플러그인 폴더를 찾을 수 없습니다', 'red');
        return false;
            }
            
    log('🎉 빌드 완료!', 'green');
    log(`📁 빌드 위치: ${buildDir}`, 'blue');
    log('💡 StreamDock을 재시작하면 플러그인이 활성화됩니다', 'cyan');
    return true;
    }
    
// 개발 빌드 함수
function buildDev() {
    log('🔨 Streamingle Camera Plugin 개발 빌드 시작...', 'cyan');
    
    const buildDir = path.join(CURRENT_DIR, 'dist-dev');
    const pluginDir = CURRENT_DIR;
    
    // 기존 빌드 폴더 정리
    if (fs.existsSync(buildDir)) {
        removeDirectory(buildDir);
    }
    
    // 빌드 폴더 생성
    fs.mkdirSync(buildDir, { recursive: true });
    
    // 플러그인 폴더 복사
    if (fs.existsSync(pluginDir)) {
        copyDirectory(pluginDir, path.join(buildDir, PLUGIN_NAME));
        log('✅ 플러그인 파일 복사 완료', 'green');
    } else {
        log('❌ 플러그인 폴더를 찾을 수 없습니다', 'red');
        return false;
    }
    
    log('🎉 개발 빌드 완료!', 'green');
    log(`📁 빌드 위치: ${buildDir}`, 'blue');
    return true;
}

// StreamDock에 배포 함수
function deploy() {
    log('🚀 StreamDock에 플러그인 배포 시작...', 'magenta');
    
    const pluginDir = CURRENT_DIR;
    const streamdockPluginPath = path.join(STREAMDOCK_PLUGINS_PATH, PLUGIN_NAME);
    
    // StreamDock 플러그인 폴더 확인
    if (!fs.existsSync(STREAMDOCK_PLUGINS_PATH)) {
        log('❌ StreamDock 플러그인 폴더를 찾을 수 없습니다', 'red');
        log(`📁 예상 경로: ${STREAMDOCK_PLUGINS_PATH}`, 'yellow');
        return false;
    }
    
    // 기존 플러그인 삭제
    if (fs.existsSync(streamdockPluginPath)) {
        removeDirectory(streamdockPluginPath);
        log('🗑️ 기존 플러그인 삭제 완료', 'yellow');
            }
            
    // 새 플러그인 복사
    if (fs.existsSync(pluginDir)) {
        copyDirectory(pluginDir, streamdockPluginPath);
        log('✅ 플러그인 복사 완료', 'green');
    } else {
        log('❌ 플러그인 폴더를 찾을 수 없습니다', 'red');
        return false;
                }
    
    log('🎉 StreamDock 배포 완료!', 'green');
    log(`📁 배포 위치: ${streamdockPluginPath}`, 'blue');
    log('💡 StreamDock을 재시작하면 플러그인이 활성화됩니다', 'cyan');
    return true;
    }
    
// 개발용 배포 함수 (빌드 후 배포)
function deployDev() {
    log('🚀 개발용 StreamDock 배포 시작...', 'magenta');
    
    // 먼저 빌드
    if (!buildDev()) {
        return false;
    }
    
    const buildDir = path.join(CURRENT_DIR, 'dist-dev', PLUGIN_NAME);
    const streamdockPluginPath = path.join(STREAMDOCK_PLUGINS_PATH, PLUGIN_NAME);
        
    // StreamDock 플러그인 폴더 확인
    if (!fs.existsSync(STREAMDOCK_PLUGINS_PATH)) {
        log('❌ StreamDock 플러그인 폴더를 찾을 수 없습니다', 'red');
        log(`📁 예상 경로: ${STREAMDOCK_PLUGINS_PATH}`, 'yellow');
        return false;
    }
    
    // 기존 플러그인 삭제
    if (fs.existsSync(streamdockPluginPath)) {
        removeDirectory(streamdockPluginPath);
        log('🗑️ 기존 플러그인 삭제 완료', 'yellow');
    }
    
    // 새 플러그인 복사
    if (fs.existsSync(buildDir)) {
        copyDirectory(buildDir, streamdockPluginPath);
        log('✅ 플러그인 복사 완료', 'green');
    } else {
        log('❌ 빌드된 플러그인 폴더를 찾을 수 없습니다', 'red');
        return false;
    }
    
    log('🎉 개발용 StreamDock 배포 완료!', 'green');
    log(`📁 배포 위치: ${streamdockPluginPath}`, 'blue');
    log('💡 StreamDock을 재시작하면 플러그인이 활성화됩니다', 'cyan');
    return true;
}

// 정리 함수
function clean() {
    log('🧹 빌드 폴더 정리 시작...', 'yellow');
    
    const buildDir = path.join(CURRENT_DIR, 'dist');
    const buildDevDir = path.join(CURRENT_DIR, 'dist-dev');
            
    if (fs.existsSync(buildDir)) {
        removeDirectory(buildDir);
        log('✅ dist 폴더 삭제 완료', 'green');
    }
            
    if (fs.existsSync(buildDevDir)) {
        removeDirectory(buildDevDir);
        log('✅ dist-dev 폴더 삭제 완료', 'green');
    }
    
    log('🎉 정리 완료!', 'green');
}

// 도움말 함수
function help() {
    log('📖 Streamingle Camera Plugin 빌드 도구', 'cyan');
    log('', 'white');
    log('사용법:', 'yellow');
    log('  node build.js <명령>', 'white');
    log('', 'white');
    log('명령:', 'yellow');
    log('  build        - 프로덕션 빌드 (dist 폴더에 생성)', 'white');
    log('  build:dev    - 개발 빌드 (dist-dev 폴더에 생성)', 'white');
    log('  deploy       - StreamDock에 직접 배포', 'white');
    log('  deploy:dev   - 개발 빌드 후 StreamDock에 배포', 'white');
    log('  clean        - 빌드 폴더 정리', 'white');
    log('  help         - 이 도움말 표시', 'white');
    log('', 'white');
    log('예시:', 'yellow');
    log('  node build.js deploy     # 바로 StreamDock에 배포', 'white');
    log('  node build.js deploy:dev # 개발 빌드 후 배포', 'white');
}

// 메인 실행
const command = process.argv[2];

    switch (command) {
        case 'build':
        build();
        break;
    case 'build:dev':
        buildDev();
        break;
    case 'deploy':
        deploy();
            break;
    case 'deploy:dev':
        deployDev();
            break;
        case 'clean':
        clean();
        break;
    case 'help':
    case '--help':
    case '-h':
        help();
            break;
        default:
        log('❌ 알 수 없는 명령입니다', 'red');
        log('', 'white');
        help();
            break;
    }