/**
 * Copyright (c) 2021 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */

#include "scaledtexture.h"

assetmanageritem_t * assetManagerLoadScaledTexture(
  assetmanager_t *manager, assetmanagerowner_t owner,
  char *path, char *file, uint8_t scale
) {
  assetmanageritem_t *item;
  texturescale_t *st;
  char buffer[ASSET_MANAGER_ITEM_NAME_MAX];
  
  sprintf(buffer, "%s/%s_%u", path, file, scale);
  item = assetManagerItemGet(manager, buffer);
  
  if(item == NULL) {
    item = assetManagerItemAdd(manager, buffer);
    item->type = ASSET_MANAGER_TYPE_SCALED_TEXTURE;
    item->data.scaledTexture.scale = scale;

    st = &item->data.scaledTexture.textureScale;
    st->scaleCount = 0;
    st->baseWidth = 0;
    st->baseHeight = 0;
    st->path = path;
    st->file = file;
  }

  assetManagerItemGetOrAddHolder(item, owner);
  return item;
}

bool _assetManagerLoaderScaledTextureAsync(assetmanageritem_t *item) {
  char buffer[128];
  char *xmlData;
  xml_t xml;
  xml_t *child;
  int16_t i, j;
  texturescale_t *st;
  texturescalescale_t *sts;
  size_t length;

  // TODO: This can be improved if we allow both asset dependencies and 
  // dependency sibling adding

  st = &item->data.scaledTexture.textureScale;

  // Begin loading texture XML
  sprintf(buffer, "%s/%s.xml", st->path, st->file);

  xmlData = assetStringLoad(buffer);
  if(xmlData == NULL) return false;
  xmlLoad(&xml, xmlData);
  free(xmlData);

  // Parse root texture info
  i = xmlGetAttributeByName(&xml, "channels");
  st->channels = (uint8_t)atoi(xml.attributeDatas[i]);
  i = xmlGetAttributeByName(&xml, "width");
  st->baseWidth = (int16_t)atoi(xml.attributeDatas[i]);
  i = xmlGetAttributeByName(&xml, "height");
  st->baseHeight = (int16_t)atoi(xml.attributeDatas[i]);

  for(j = 0; j < xml.childrenCount; j++) {
    child = xml.children + j;
    i = xmlGetAttributeByName(child, "scale");
    st->scales[st->scaleCount].scale = (uint8_t)atoi(child->attributeDatas[i]);
    i = xmlGetAttributeByName(child, "width");
    st->scales[st->scaleCount].width = (int16_t)atoi(child->attributeDatas[i]);
    i = xmlGetAttributeByName(child, "height");
    st->scales[st->scaleCount].height = (int16_t)atoi(child->attributeDatas[i]);
    st->scaleCount++;
  }

  // Cleanup XML
  xmlDispose(&xml);

  // Get the scale
  sts = st->scales + item->data.scaledTexture.scale;

  // Get filename
  sprintf(buffer, "%s/%s_%i.texture", st->path, st->file, sts->scale);

  // Create some space
  length = assetRawLoad(buffer, NULL);
  if(length == 0) return false;
  item->data.scaledTexture.data = malloc(sizeof(pixel_t) * length);

  // Load
  length = assetRawLoad(buffer, (uint8_t *)item->data.scaledTexture.data);
  if(length == 0) {
    free(item->data.scaledTexture.data);
    return false;
  }
  
  return true;
}

bool _assetManagerLoaderScaledTextureSync(assetmanageritem_t *item) {
  texturescale_t *st;
  texturescalescale_t *sts;
  st = &item->data.scaledTexture.textureScale;
  sts = st->scales + item->data.scaledTexture.scale;

  textureInit(
    &item->data.scaledTexture.texture,
    sts->width, sts->height,
    item->data.scaledTexture.data
  );

  free(item->data.scaledTexture.data);
  return true;
}

bool _assetManagerLoaderScaledTextureDispose(assetmanageritem_t *item) {
  textureDispose(&item->data.scaledTexture.texture);
  return true;
}