var gltf = use('gltf')
var obj = use('obj')
var fbx = use('fbx')
var fs = use('cellfs')

if (args.length < 1) {
  log.console("Usage: cell run tests/readout.ce <model_file>")
  log.console("Supported formats: .gltf, .glb, .obj, .fbx")
  $_.stop()
}

var filepath = args[0]
var dot = filepath.lastIndexOf('.')
var ext = dot >= 0 ? filepath.slice(dot).toLowerCase() : ''

var data = fs.slurp(filepath)
if (!data) {
  log.console(`Error: Could not read file: ${filepath}`)
  $_.stop()
}

var model = null
if (ext == '.gltf' || ext == '.glb') {
  model = gltf.decode(data)
} else if (ext == '.obj') {
  model = obj.decode(data)
} else if (ext == '.fbx') {
  model = fbx.decode(data)
} else {
  log.console(`Error: Unsupported file format: ${ext}`)
  log.console("Supported formats: .gltf, .glb, .obj, .fbx")
  $_.stop()
}

def print_array = function(arr, indent) {
  if (!arr || arr.length == 0) {
    log.console(`${indent}(empty)`)
    return
  }
  for (var i = 0; i < arr.length; i++) {
    var item = arr[i]
    if (typeof item == 'object' && item != null) {
      log.console(`${indent}[${i}]:`)
      print_object(item, indent + "  ")
    } else {
      log.console(`${indent}[${i}]: ${item}`)
    }
  }
}

def print_object = function(obj, indent) {
  if (!indent) indent = ""
  var keys = Object.keys(obj)
  for (var i = 0; i < keys.length; i++) {
    var key = keys[i]
    var val = obj[key]
    if (val == null) {
      log.console(`${indent}${key}: null`)
    } else if (typeof val == 'object') {
      if (val.constructor && val.constructor.name == 'Blob') {
        log.console(`${indent}${key}: <Blob ${val.length} bytes>`)
      } else if (Array.isArray(val)) {
        if (val.length == 0) {
          log.console(`${indent}${key}: []`)
        } else if (val.length <= 4 && typeof val[0] != 'object') {
          log.console(`${indent}${key}: [${val.join(', ')}]`)
        } else if (typeof val[0] != 'object') {
          log.console(`${indent}${key}: [${val.slice(0, 4).join(', ')}...] (${val.length} items)`)
        } else {
          log.console(`${indent}${key}: (${val.length} items)`)
          print_array(val, indent + "  ")
        }
      } else {
        log.console(`${indent}${key}:`)
        print_object(val, indent + "  ")
      }
    } else {
      log.console(`${indent}${key}: ${val}`)
    }
  }
}

log.console(`\n=== Model Structure: ${filepath} ===\n`)

log.console(`Buffers: ${model.buffers.length}`)
for (var i = 0; i < model.buffers.length; i++) {
  var buf = model.buffers[i]
  log.console(`  [${i}] byte_length: ${buf.byte_length}`)
}

log.console(`\nViews: ${model.views.length}`)
for (var i = 0; i < model.views.length; i++) {
  var v = model.views[i]
  log.console(`  [${i}] buffer: ${v.buffer}, offset: ${v.byte_offset}, length: ${v.byte_length}, stride: ${v.byte_stride}, usage: ${v.usage}`)
}

log.console(`\nAccessors: ${model.accessors.length}`)
for (var i = 0; i < model.accessors.length; i++) {
  var a = model.accessors[i]
  log.console(`  [${i}] view: ${a.view}, offset: ${a.byte_offset}, count: ${a.count}, type: ${a.component_type}/${a.type}, normalized: ${a.normalized}`)
}

log.console(`\nMeshes: ${model.meshes.length}`)
for (var i = 0; i < model.meshes.length; i++) {
  var m = model.meshes[i]
  log.console(`  [${i}] name: ${m.name}`)
  for (var j = 0; j < m.primitives.length; j++) {
    var p = m.primitives[j]
    log.console(`    primitive[${j}]: topology: ${p.topology}, indices: ${p.indices}, material: ${p.material}`)
    var ak = Object.keys(p.attributes)
    var parts = []
    for (var k = 0; k < ak.length; k++) parts.push(ak[k] + ': ' + text(p.attributes[ak[k]]))
    log.console('      attributes: {' + parts.join(', ') + '}')
  }
}

log.console(`\nMaterials: ${model.materials.length}`)
for (var i = 0; i < model.materials.length; i++) {
  var m = model.materials[i]
  log.console(`  [${i}] name: ${m.name}, alpha_mode: ${m.alpha_mode}, double_sided: ${m.double_sided}`)
  if (m.pbr) {
    log.console(`    pbr: base_color: [${m.pbr.base_color_factor}], metallic: ${m.pbr.metallic_factor}, roughness: ${m.pbr.roughness_factor}`)
  }
}

log.console(`\nImages: ${model.images.length}`)
for (var i = 0; i < model.images.length; i++) {
  var im = model.images[i]
  log.console(`  [${i}] kind: ${im.kind}, ${im.kind == 'uri' ? 'uri: ' + im.uri : 'view: ' + im.view}, mime: ${im.mime}`)
}

log.console(`\nTextures: ${model.textures.length}`)
for (var i = 0; i < model.textures.length; i++) {
  var t = model.textures[i]
  log.console(`  [${i}] image: ${t.image}, sampler: ${t.sampler}`)
}

log.console(`\nSamplers: ${model.samplers.length}`)
for (var i = 0; i < model.samplers.length; i++) {
  var s = model.samplers[i]
  log.console(`  [${i}] min: ${s.min_filter}, mag: ${s.mag_filter}, wrap_s: ${s.wrap_s}, wrap_t: ${s.wrap_t}`)
}

log.console(`\nNodes: ${model.nodes.length}`)
for (var i = 0; i < model.nodes.length; i++) {
  var n = model.nodes[i]
  log.console(`  [${i}] name: ${n.name}, mesh: ${n.mesh}, children: [${n.children}], skin: ${n.skin}`)
  if (n.matrix) {
    log.console(`    matrix: [${n.matrix.slice(0, 4)}...]`)
  } else {
    log.console(`    T: [${n.translation}], R: [${n.rotation}], S: [${n.scale}]`)
  }
}

log.console(`\nScenes: ${model.scenes.length}, default: ${model.scene}`)
for (var i = 0; i < model.scenes.length; i++) {
  var s = model.scenes[i]
  log.console(`  [${i}] nodes: [${s.nodes}]`)
}

log.console(`\nAnimations: ${model.animations.length}`)
for (var i = 0; i < model.animations.length; i++) {
  var a = model.animations[i]
  log.console(`  [${i}] name: ${a.name}, samplers: ${a.samplers.length}, channels: ${a.channels.length}`)
}

log.console(`\nSkins: ${model.skins.length}`)
for (var i = 0; i < model.skins.length; i++) {
  var s = model.skins[i]
  log.console(`  [${i}] name: ${s.name}, joints: ${s.joints.length}, ibm: ${s.inverse_bind_matrices}, skeleton: ${s.skeleton}`)
}

log.console(`\nExtensions:`)
log.console(`  used: [${model.extensions.used}]`)
log.console(`  required: [${model.extensions.required}]`)

log.console(`\n=== End ===\n`)

log.console(json.encode(model))

$_.stop()