#include <assets/builtin/builtin_asset_factory.h>
#include <utils/logger.h>

namespace extra2d {

BuiltinAssetFactory::BuiltinAssetFactory(AssetStorage<Texture> &textures,
                                         AssetStorage<Shader> &shaders,
                                         AssetStorage<Material> &materials,
                                         AssetStorage<Mesh> &meshes,
                                         const AssetFileSystem &fileSystem)
    : textures_(textures), shaders_(shaders), materials_(materials), meshes_(meshes),
      fileSystem_(fileSystem) {}

bool BuiltinAssetFactory::create() {
  {
    Ptr<Texture> texture = makePtr<Texture>();
    uint8_t whitePixel[] = {255, 255, 255, 255};
    if (!texture->loadFromMemory(whitePixel, 1, 1, TextureFormat::RGBA8)) {
      return false;
    }
    defaultTexture_ = textures_.insert(texture);
  }

  {
    std::string vertPath = fileSystem_.assetPath("shader/default.vert");
    std::string fragPath = fileSystem_.assetPath("shader/default.frag");
    if (!fileSystem_.exists(vertPath) || !fileSystem_.exists(fragPath)) {
      return false;
    }
    std::string vsSource = fileSystem_.readString(vertPath);
    std::string fsSource = fileSystem_.readString(fragPath);
    if (vsSource.empty() || fsSource.empty()) {
      return false;
    }
    Ptr<Shader> shader = makePtr<Shader>();
    if (!shader->loadFromSource(vsSource, fsSource)) {
      return false;
    }
    defaultShader_ = shaders_.insert(shader);
  }

  {
    Ptr<MaterialLayout> layout = makePtr<MaterialLayout>();
    layout->addParam("uColor", MaterialParamType::Color);
    layout->addParam("uTintColor", MaterialParamType::Color);
    layout->addParam("uOpacity", MaterialParamType::Float);
    layout->finalize();

    Ptr<Material> material = makePtr<Material>();
    material->setShader(shaders_.getPtr(defaultShader_));
    material->setLayout(layout);
    material->setColor("uColor", Color::White);
    material->setColor("uTintColor", Color::White);
    material->setFloat("uOpacity", 1.0f);
    material->setTexture("uTexture", textures_.getPtr(defaultTexture_), 0);
    defaultMaterial_ = materials_.insert(material);
  }

  {
    Ptr<Mesh> mesh = Mesh::createQuad(Vec2(1.0f, 1.0f));
    if (!mesh) {
      return false;
    }
    defaultQuad_ = meshes_.insert(mesh);
  }

  E2D_DEBUG("BuiltinAssetFactory: 默认资源创建完成");
  return true;
}

void BuiltinAssetFactory::destroy() {
  materials_.remove(defaultMaterial_);
  meshes_.remove(defaultQuad_);
  textures_.remove(defaultTexture_);
  shaders_.remove(defaultShader_);
  defaultMaterial_ = Handle<Material>::invalid();
  defaultQuad_ = Handle<Mesh>::invalid();
  defaultTexture_ = Handle<Texture>::invalid();
  defaultShader_ = Handle<Shader>::invalid();
}

Handle<Texture> BuiltinAssetFactory::defaultTexture() const {
  return defaultTexture_;
}

Handle<Shader> BuiltinAssetFactory::defaultShader() const { return defaultShader_; }

Handle<Material> BuiltinAssetFactory::defaultMaterial() const {
  return defaultMaterial_;
}

Handle<Mesh> BuiltinAssetFactory::defaultQuad() const { return defaultQuad_; }

} // namespace extra2d