index.js

const fs = require('fs');
const path = require('path');
const crypto = require('crypto');
const AdmZip = require('adm-zip');

async function getFileHash(filePath) {
  const hashSum = crypto.createHash('sha256');
  const stream = fs.createReadStream(filePath);

  return new Promise((resolve, reject) => {
    stream.on('data', (chunk) => {
      hashSum.update(chunk);
    });
    stream.on('end', () => {
      resolve(hashSum.digest('hex'));
    });
    stream.on('error', reject);
  });
}

async function isSameFile(sourcePath, destPath) {
  try {
    const sourceStat = await fs.promises.stat(sourcePath);
    const destStat = await fs.promises.stat(destPath);
    if (sourceStat.size !== destStat.size) {
      return false;
    }

    const sourceHash = await getFileHash(sourcePath);
    const destHash = await getFileHash(destPath);

    return sourceHash === destHash;
  } catch (err) {
    return false;
  }
}

async function copyFile(sourcePath, destPath) {
  const destDir = path.dirname(destPath);

  if (!fs.existsSync(destDir)) {
    fs.mkdirSync(destDir, { recursive: true });
  }

  if (fs.existsSync(destPath) && await isSameFile(sourcePath, destPath)) {
    console.log(`Skipping ${sourcePath} -> ${destPath} (already exists and identical)`);
    return;
  }

  await fs.promises.copyFile(sourcePath, destPath);
  console.log(`Copied ${sourcePath} -> ${destPath}`);
}

async function copyDirectory(sourceDir, destDir) {
  if (!fs.existsSync(destDir)) {
    fs.mkdirSync(destDir, { recursive: true });
  }

  const items = fs.readdirSync(sourceDir);

  for (const item of items) {
    const sourcePath = path.join(sourceDir, item);
    const destPath = path.join(destDir, item);

    const stat = fs.statSync(sourcePath);

    if (stat.isDirectory()) {
      await copyDirectory(sourcePath, destPath);
    } else {
      await copyFile(sourcePath, destPath);
    }
  }
}

async function unzip(sourceZip, destDir) {
  const zip = new AdmZip(sourceZip);
  const entries = zip.getEntries();

  for (const entry of entries) {
    if (entry.isDirectory) continue;

    const destPath = path.join(destDir, entry.entryName);
    const destDirPath = path.dirname(destPath);

    if (!fs.existsSync(destDirPath)) {
      fs.mkdirSync(destDirPath, { recursive: true });
    }

    if (fs.existsSync(destPath)) {
      // ZIP 파일의 해시 계산 (entry.getData() 사용, 큰 파일 주의)
      const zipData = entry.getData();
      const zipHash = crypto.createHash('sha256').update(zipData).digest('hex');
      const destHash = await getFileHash(destPath);
      if (zipHash === destHash) {
        console.log(`Skipping ${entry.entryName} (already exists and identical)`);
        continue;
      }
    }

    // ZIP 데이터를 직접 파일로 쓰기
    const zipData = entry.getData();
    await fs.promises.writeFile(destPath, zipData);
    console.log(`Extracted ${entry.entryName} -> ${destPath}`);
  }
}

async function main() {
  const args = process.argv.slice(2);

  if (args.length !== 2) {
    console.error('Usage: node index.js <source> <destination>');
    process.exit(1);
  }

  const source = args[0];
  const destination = args[1];

  if (!fs.existsSync(source)) {
    console.error(`Source ${source} does not exist`);
    process.exit(1);
  }

  if (path.extname(source).toLowerCase() === '.zip') {
    await unzip(source, destination);
  } else {
    const sourceStat = fs.statSync(source);

    if (sourceStat.isDirectory()) {
      await copyDirectory(source, destination);
    } else {
      const destPath = path.isAbsolute(destination) ? destination : path.join(process.cwd(), destination);
      if (fs.existsSync(destPath) && fs.statSync(destPath).isDirectory()) {
        const fileName = path.basename(source);
        await copyFile(source, path.join(destPath, fileName));
      } else {
        await copyFile(source, destPath);
      }
    }
  }

  console.log('Copy operation completed.');
}

main();