#include ".\pathalgorithm.h"

PathAlgorithm::PathAlgorithm(void){
    init(0,0,0,0,0);
}
PathAlgorithm::PathAlgorithm(POINT* origin, POINT* destination){
    Node* root = new Node(0, origin);
    root->setGivenCost(0);
    root->setHeuristicCost(destination);
    init(root, destination, 0, 0, 0);
}
PathAlgorithm::PathAlgorithm(Node* root, POINT* destination, vector<Node*>* open, vector<Node*>* closed, vector<POINT*>* solution){
    init(root, destination, open, closed, solution);
}

PathAlgorithm::~PathAlgorithm(void){
    clean();
    if(open){
        delete open;
        open = 0;
    }
    if(closed){
        delete closed;
        closed = 0;
    }
    if(solution){
        delete solution;
        solution = 0;
    }
}


void PathAlgorithm::init(Node* root, POINT* destination, vector<Node*>* _open, vector<Node*>* _closed, vector<POINT*>* _solution){
    setRoot(root);
    setDestination(destination);
    _open     ? setOpen( _open )         : open = new vector<Node*>();
    _closed   ? setClosed( _closed )     : closed = new vector<Node*>();
    _solution ? setSolution( _solution ) : solution = new vector<POINT*>();
}

Node* PathAlgorithm::getRoot(){
    return root;
}
void  PathAlgorithm::setRoot(Node* _root){
    root = _root;
}
// getter setter destination
POINT* PathAlgorithm::getDestination(){
    return destination;
}
void   PathAlgorithm::setDestination(POINT* _destination){
    destination = _destination;
}
// getter setter open
vector<Node*>* PathAlgorithm::getOpen(){
    return open;
}
void PathAlgorithm::setOpen(vector<Node*>* _open){
    open = _open;
}
// getter setter closed
vector<Node*>* PathAlgorithm::getClosed(){
    return closed;
}
void PathAlgorithm::setClosed(vector<Node*>* _closed){
    closed = _closed;
}
// getter setter solution
vector<POINT*>* PathAlgorithm::getSolution(){
    return solution;
}
void PathAlgorithm::setSolution(vector<POINT*>* _solution){
    solution = _solution;
}

void PathAlgorithm::clean(){
    vector<Node*>::iterator iter;
    Node*                   node;

    iter = open->begin();
    while(iter != open->end()){
        node = (*iter);
        open->erase(iter);
        delete node;
        node = 0;
        iter = open->begin();
    }

    iter = closed->begin();
    while(iter != closed->end()){
        node = (*iter);
        closed->erase(iter);
        delete node;
        node = 0;
        iter = closed->begin();
    }
    vector<POINT*>::iterator piter;
    POINT* p;
    piter = solution->begin();
    while(piter != solution->end()){
        p = (*piter);
        solution->erase(piter);
        delete p;
        p = 0;
        piter = solution->begin();
    }
//    solution->clear();
}