// cell build [<locator>] - Build dynamic libraries locally for the current machine
//
// Usage:
//   cell build                Build dynamic libraries for all packages in shop
//   cell build .              Build dynamic library for current directory package
//   cell build <locator>      Build dynamic library for specific package
//   cell build -t <target>    Cross-compile dynamic libraries for target platform
//   cell build -b <type>      Build type: release (default), debug, or minsize

var build = use('build')
var shop = use('internal/shop')
var pkg_tools = use('package')
var fd = use('fd')

var target = null
var target_package = null
var buildtype = 'release'
var force_rebuild = false
var dry_run = false

for (var i = 0; i < args.length; i++) {
  if (args[i] == '-t' || args[i] == '--target') {
    if (i + 1 < args.length) {
      target = args[++i]
    } else {
      log.error('-t requires a target')
      $stop()
    }
  } else if (args[i] == '-p' || args[i] == '--package') {
    // Legacy support for -p flag
    if (i + 1 < args.length) {
      target_package = args[++i]
    } else {
      log.error('-p requires a package name')
      $stop()
    }
  } else if (args[i] == '-b' || args[i] == '--buildtype') {
    if (i + 1 < args.length) {
      buildtype = args[++i]
      if (buildtype != 'release' && buildtype != 'debug' && buildtype != 'minsize') {
        log.error('Invalid buildtype: ' + buildtype + '. Must be release, debug, or minsize')
        $stop()
      }
    } else {
      log.error('-b requires a buildtype (release, debug, minsize)')
      $stop()
    }
  } else if (args[i] == '--force') {
    force_rebuild = true
  } else if (args[i] == '--dry-run') {
    dry_run = true
  } else if (args[i] == '--list-targets') {
    log.console('Available targets:')
    var targets = build.list_targets()
    for (var t = 0; t < targets.length; t++) {
      log.console('  ' + targets[t])
    }
    $stop()
  } else if (!starts_with(args[i], '-') && !target_package) {
    // Positional argument - treat as package locator
    target_package = args[i]
  }
}

// Resolve local paths to absolute paths
if (target_package) {
  if (target_package == '.' || starts_with(target_package, './') || starts_with(target_package, '../') || fd.is_dir(target_package)) {
    var resolved = fd.realpath(target_package)
    if (resolved) {
      target_package = resolved
    }
  }
}

// Detect target if not specified
if (!target) {
  target = build.detect_host_target()
  if (target) log.console('Target: ' + target)
}

if (target && !build.has_target(target)) {
  log.error('Invalid target: ' + target)
  log.console('Available targets: ' + text(build.list_targets(), ', '))
  $stop()
}

var packages = shop.list_packages()
log.console('Preparing packages...')
for (var package of packages) {
  if (package == 'core') continue
  shop.extract(package)
}

if (target_package) {
  // Build single package
  log.console('Building ' + target_package + '...')
  try {
    var lib = build.build_dynamic(target_package, target, buildtype)
    if (lib) {
      log.console('Built: ' + lib)
    }
  } catch (e) {
    log.error('Build failed: ' + e)
    $stop()
  }
} else {
  // Build all packages
  log.console('Building all packages...')
  var results = build.build_all_dynamic(target, buildtype)
  
  var success = 0
  var failed = 0
  for (var i = 0; i < results.length; i++) {
    if (results[i].library) {
      success++
    } else if (results[i].error) {
      failed++
    }
  }
  
  log.console(`Build complete: ${success} libraries built${failed > 0 ? `, ${failed} failed` : ''}`)
}

$stop()