#include "LayerComposition.h"
#include "Atlas.h"
#include "MsdfLayer.h"
#include "Utils.h"
#include "ofUtils.h"
#include <memory>

namespace ofxVariableLab {

void LayerComposition::setup(){
}

void LayerComposition::update(){
    for(const auto & atlasLayerCombo : atlasLayerCombos){
        atlasLayerCombo.second->update();
    }
}

LayerID LayerComposition::addLayer(const ComboIdentifier & identifier,
                                   const string & text,
                                   const std::vector <FontVariation> & variations){
    auto props = Layer::Props();
    props.text = text;
    props.fontPath = identifier.fontPath;
    return addLayer(identifier,
                    props,
                    variations);
}

LayerID LayerComposition::addLayer(const ComboIdentifier & identifier,
                                   const Layer::Props & props,
                                   const std::vector <FontVariation> & variations){
    string layerID = "";
    if(atlasLayerCombos.count(identifier) <= 0){
        switch(identifier.type){
         case Layer::GPUFONT: {
             ofLogError("LayerComposition::addLayer")
                 << "GPUFont not implemented" << endl;
             break;
         }

         default:
         case Layer::MSDFGEN: {
             // TODO: put most stuff in combo setup
             auto combo = make_shared <MsdfAtlasLayerCombo>();
             combo->setup(identifier); // TODO: add here text and variations
             auto layer = make_shared <MsdfLayer>();
             layer->vFlip = vFlipState;
             layer->setProps(props);
             layer->setup();
             std::vector <ofxMsdfgen::FontVariation> msdfVariations;
             for(const auto & v : variations){
                 msdfVariations.push_back({v.name, v.value});
             }
             // TODO: do not add Variation to atlas, but to combo,
             // so we know it's dirty
             combo->atlas->addVariations(msdfVariations);
             combo->careForChild(layer);
             layers[layer->getId()] = layer;
             atlasLayerCombos[identifier] = std::move(combo);
             layerID = layer->getId();
         }
        }
    }
    return layerID;
}

shared_ptr <Layer> LayerComposition::getLayer(const LayerID & layerID){
    return layers[layerID];
}

void LayerComposition::draw() const {
    for(const auto & layer_it : layers){
        layer_it.second->draw();
    }
}

const unordered_map <ComboIdentifier, shared_ptr <AtlasLayerCombo> > & LayerComposition::getAtlasLayerCombos() const {
    return atlasLayerCombos;
}

void LayerComposition::setVFlip(bool vFlip){
    vFlipState = vFlip ? V_FLIP_ON : V_FLIP_OFF;
    for(auto & layer : layers){
        layer.second->setVFlip(vFlipState);
    }
}

}