#include "EditManager.h"
#include "Window.h"


bool EditManager::lineOk(const Room &newRoom, const Line &l) const {
  Line l2;
  
  for(size_t i = 0; i+2 < newRoom.getPolygon().size(); i++) {
    l2.setVertex1(newRoom.getPolygon()[i]);
    l2.setVertex2(newRoom.getPolygon()[i+1]);
    
    if(l.intersects(l2, NULL) == INTERSECTION_SEGMENT_SEGMENT) return false;
  }
  
  if(newRoom.getPolygon().size() > 1) {
    l2.setVertex1(newRoom.getPolygon()[newRoom.getPolygon().size()-2]);
    l2.setVertex2(newRoom.getPolygon().back());
    if(l2.contains(l.getVertex2())) return false;
  }
  
  for(Level::iterator room = window->getLevel().begin(); room != window->getLevel().end(); room++) {
    if((*room)->isOfType("Room") && ((Room*)&**room)->getPolygon().intersects(l))
      return false;
  }
  
  return true;
}


EditManager::EditManager(Window *window) {
  this->window = window;
  
  hoveredObject = NULL;
  selectedObject = NULL;
  
  hasHoveredVertex = false;
}

void EditManager::redraw() {
  window->redraw();
}

bool EditManager::addRoom(const Room &newRoom) {
  if(newRoom.getPolygon().size() > 2 && polygonOk(newRoom.getPolygon())) {
    Room *room = new Room(newRoom);
    room->setName(idManager.generate("room"));
    
    window->getLevel().addWithChildren(SharedPtr<LevelObject>(room));
    selectedObject = room;
    
    window->resetTool();
    
    return true;
  }
  
  return false;
}

const Vertex* EditManager::getHoveredVertex() const {
  if(hasHoveredVertex) return &hoveredVertex;
  else return NULL;
}

void EditManager::setHoveredVertex(const Vertex *v, float scale) {
  if(v) {
    hasHoveredVertex = true;
    hoveredVertex = *v;
    
    hoveredObject = NULL;
    
    for(Level::iterator object = window->getLevel().begin(); object != window->getLevel().end(); object++) {
      if(!window->getActiveTool()->hoverFilter(**object))
        continue;
      
      if((*object)->hit(*v, scale)) {
        if(hoveredObject && (*object)->getPriority() < hoveredObject->getPriority())
          continue;
        
        hoveredObject = &**object;
      }
    }
  }
  else {
    hasHoveredVertex = false;
    hoveredObject = NULL;
  }
  
  window->update();
}

bool EditManager::vertexOk(const Vertex &v, const Room *newRoom) const {
  Line l;
  
  for(Level::iterator room = window->getLevel().begin(); room != window->getLevel().end(); room++) {
    if((*room)->isOfType("Room") && ((Room*)&**room)->getPolygon().contains(v)) return false;
  }
  
  if(!newRoom)
    return true;
  
  if(newRoom->getPolygon().empty())
    return true;
  
  l.setVertex1(newRoom->getPolygon().back());
  l.setVertex2(v);
  
  return lineOk(*newRoom, l);
}

bool EditManager::polygonOk(const Polygon& polygon) const {
  Line l, l2;
  
  if(polygon.empty()) return false;
  
  for(Level::iterator object = window->getLevel().begin(); object != window->getLevel().end(); object++) {
    if(!(*object)->isOfType("Room"))
      continue;
    
    Room *room = (Room*)&**object;
    
    if(room->getPolygon().empty()) continue;
    
    if(room->getPolygon().contains(polygon.front()))
      return false;
    
    if(polygon.contains(room->getPolygon().front()))
      return false;
  }
  
  if(polygon.size() == 1)
    return true;
  
  if(!polygon.isSimple())
    return false;
  
  for(Polygon::const_iterator it = polygon.begin(); it != polygon.end(); it++) {
    Polygon::const_iterator it2 = it+1;
    if(it2 == polygon.end()) it2 = polygon.begin();
    
    l.setVertex1(*it);
    l.setVertex2(*it2);
    
    for(Level::iterator room = window->getLevel().begin(); room != window->getLevel().end(); room++) {
      if((*room)->isOfType("Room") && ((Room*)&**room)->getPolygon().intersects(l))
        return false;
    }
  }
  
  return true;
}