//
//  IMapController.h
//  SteveMaggieCpp
//
//  Created by Katarzyna Kalinowska-Górska on 17.05.2017.
//
//

#include "AniGardenMapController.h"
#include "AniMathUtils.h"
#include "AniMapLayer.h"

void AniGardenMapController::shuffleAllPickupMapAdventureObjects(const std::vector<std::string> excludedObjects){
    auto allPickupAdventureObjects = getAllPickupItems(excludedObjects);
//    std::vector<MapAdventureObjectPickupItem*> swappedItems;
    // choose random pairs to swap
    shuffleConcretePickupMapAdventureObjects(allPickupAdventureObjects);
}

void AniGardenMapController::shuffleConcretePickupMapAdventureObjects(std::vector<MapAdventureObjectPickupItem*> objects){
    do {
        auto randomObjectIndex = AniMathUtils::getRandomInt(0, objects.size()-1);
        auto object1 = objects[randomObjectIndex];
        objects.erase(objects.begin() + randomObjectIndex);
        randomObjectIndex = AniMathUtils::getRandomInt(0, objects.size()-1);
        auto object2 = objects[randomObjectIndex];
        objects.erase(objects.begin() + randomObjectIndex);
        auto position1 = object1->getAssociatedMapImageObjects().begin()->second->getPosition();
        auto position2 = object2->getAssociatedMapImageObjects().begin()->second->getPosition();
        object1->getAssociatedMapImageObjects().begin()->second->setPosition(position2);
        object2->getAssociatedMapImageObjects().begin()->second->setPosition(position1);
        object1->resetOccupiedTileIfNecessary();
        object2->resetOccupiedTileIfNecessary();
        remapAdventureObject(object1);
        remapAdventureObject(object2);
    } while(objects.size() > 1);
    
//    if(objects.size() > 0){
//        // TODO
//        // if we ever need it. in our game, we have 8 objects
//    }
}

void AniGardenMapController::distributeConcretePickupMapAdventureObjectsRandomly(const std::vector<MapAdventureObjectPickupItem*> objects){
    AniMapUtils::TileData tile;
    cocos2d::Point newPos;
    for(auto it = objects.begin(); it < objects.end(); ++it){
        do {
            newPos = AniMapUtils::getInstance().getRandomFreeTile(tile, m_map, getTileLayer());
        } while ( getAdventureObjectsAtTile(tile).size() > 0 ); //do not place pickup items on tiles already occupied by adventure objects
        (*it)->getAssociatedMapImageObjects().begin()->second->setPosition(newPos);
        (*it)->resetOccupiedTileIfNecessary();
        remapAdventureObject(*it);
    }
}

void AniGardenMapController::distributeAllPickupMapAdventureObjectsRandomly(const std::vector<std::string> excludedObjects){
    auto allPickupAdventureObjects = getAllPickupItems(excludedObjects);
    distributeConcretePickupMapAdventureObjectsRandomly(allPickupAdventureObjects);
}

std::vector<MapAdventureObjectPickupItem*> AniGardenMapController::generatePickupObjectsRandomly(int count, std::string baseName, std::string spriteFilePath, bool oneTileObjects){
    //generate and add to m_adventureObjects
    std::vector<MapAdventureObjectPickupItem*> items;
    
    for(int i = 0; i < count; ++i){
        auto name = baseName + "_" + std::to_string(i+1);
        IMapImageObject* mapImageObject = IMapImageObject::create(spriteFilePath, name, m_map);
        auto adventureObject = new MapAdventureObjectPickupItem(name, mapImageObject, oneTileObjects);
        m_adventureObjects.push_back(adventureObject);
        m_mapImageObjects[name] = mapImageObject;
        
        auto maplayer = dynamic_cast<AniMapLayer*>(m_map->getParent());
        maplayer->addNewObject(mapImageObject);
        mapImageObject->setLocalZOrder(getMaxObjectDepth()+1);
        AniMapUtils::TileData tile;
        cocos2d::Point newPos;
        do {
            newPos = AniMapUtils::getInstance().getRandomFreeTile(tile, m_map, getTileLayer());
        } while ( getAdventureObjectsAtTile(tile).size() > 0 ); //do not place pickup items on tiles already occupied by adventure objects
        mapImageObject->setPosition(newPos);
        adventureObject->resetOccupiedTileIfNecessary();
        remapAdventureObject(adventureObject);
        items.push_back(adventureObject);
    }
    return items;
}

//void AniGardenMapController::removePickupObjects(std::vector<std::string> objectNames){
//    
//}

void AniGardenMapController::deactivateAllObjects(const std::vector<std::string> excludedObjects){
    auto allPickupAdventureObjects = getAllPickupItems(excludedObjects);
    for(auto it = allPickupAdventureObjects.begin(); it < allPickupAdventureObjects.end(); ++it){
        (*it)->setActive(false);
    }
}

void AniGardenMapController::activateAllObjects(const std::vector<std::string> excludedObjects){
    auto allPickupAdventureObjects = getAllPickupItems(excludedObjects);
    activateConcreteObjects(allPickupAdventureObjects);
}

void AniGardenMapController::activateConcreteObjects(const std::vector<MapAdventureObjectPickupItem*> objects){
    for(auto it = objects.begin(); it < objects.end(); ++it){
        (*it)->setActive(true);
    }
}

void AniGardenMapController::hideAllObjects(const std::vector<std::string> excludedObjects){
    auto allPickupAdventureObjects = getAllPickupItems(excludedObjects);
    for(auto it = allPickupAdventureObjects.begin(); it < allPickupAdventureObjects.end(); ++it){
        hideObject(*it);
    }
}

void AniGardenMapController::showAllObjects(const std::vector<std::string> excludedObjects){
    auto allPickupAdventureObjects = getAllPickupItems(excludedObjects);
    showConcreteObjects(allPickupAdventureObjects);
}

void AniGardenMapController::showConcreteObjects(const std::vector<MapAdventureObjectPickupItem*> objects){
    for(auto it = objects.begin(); it < objects.end(); ++it){
        showObject(*it);
    }
}

void AniGardenMapController::hideObject(MapAdventureObjectPickupItem* object){
    auto mapObjects = object->getAssociatedMapImageObjects();
    for(auto it = mapObjects.begin(); it != mapObjects.end(); ++it){
        (*it).second->setOpacity(0);
    }
}

void AniGardenMapController::showObject(MapAdventureObjectPickupItem* object){
    auto mapObjects = object->getAssociatedMapImageObjects();
    for(auto it = mapObjects.begin(); it != mapObjects.end(); ++it){
        (*it).second->setOpacity(255);
    }
}

std::vector<MapAdventureObjectPickupItem*> AniGardenMapController::getAllPickupItems(const std::vector<std::string> except){
    std::vector<MapAdventureObjectPickupItem*> allPickupAdventureObjects;
    for(auto it = m_adventureObjects.begin(); it < m_adventureObjects.end(); ++it){
        auto pickupItem = dynamic_cast<MapAdventureObjectPickupItem*>(*it);
        if(pickupItem != nullptr && std::find(except.begin(), except.end(), pickupItem->getObjectName()) == except.end()){
            allPickupAdventureObjects.push_back(pickupItem);
        }
    }
    return allPickupAdventureObjects;
}