#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include "../include/dijkstra.h"
#include "../include/priority_queue.h"

typedef struct element{
    int dist;
    int x;
    int y;
} element;

bool compare(element* e1, element* e2){
    return e1->dist > e2->dist;
}

void toString(element* e){
    printf("(%d) %d %d\n", e->dist, e->x, e->y);
}

void dijkstra_r(Labyrinth* labyrinth, int i, int j, int dist, priority_queue* queue);

// dijkstra search algorithm
void dijkstra(Labyrinth* labyrinth){
    priority_queue(queue, compare);
    queue->toString = toString;

    element* tmp = (element*)malloc(sizeof(element));
    tmp->dist = 0;
    tmp->x = labyrinth->start.x;
    tmp->y = labyrinth->start.y;
    labyrinth->at[tmp->x][tmp->y].dp = 0;
    priority_queuePush(queue, tmp);

    int a, b, c;

    while(!priority_queueIsEmpty(queue)){
        a = ((element*)priority_queueTop(queue))->dist;
        b = ((element*)priority_queueTop(queue))->x;
        c = ((element*)priority_queueTop(queue))->y;

        priority_queuePop(queue);
        
        dijkstra_r(labyrinth, b, c, a, queue);
        printLab(labyrinth);
    }
    priority_queueFree(queue);

    find_path(labyrinth);
    printf("test\n");
}

// ricursive function used by dijkstra
void dijkstra_r(Labyrinth* labyrinth, int i, int j, int dist, priority_queue* queue){

    if(i==labyrinth->end.x && j==labyrinth->end.y){
        priority_queueClear(queue);
        return;
    }

    if(dist)
        labyrinth->at[i][j].color = GREEN;
    
    // adds all four directions to the priority_queue
    if(i>0 && labyrinth->at[i-1][j].south && labyrinth->at[i-1][j].dp<0){
        element* tmp = (element*)malloc(sizeof(element));
        tmp->dist = dist+1;
        tmp->x = i-1;
        tmp->y = j;

        priority_queuePush(queue, tmp);

        if(i-1!=labyrinth->end.x || j!=labyrinth->end.y)
            labyrinth->at[i-1][j].color = ORANGE;
        labyrinth->at[i-1][j].direction = UP;
        labyrinth->at[i-1][j].dp = dist+1;
    }
    if(j<labyrinth->y_size-1 && labyrinth->at[i][j].east && labyrinth->at[i][j+1].dp<0){
        element* tmp = (element*)malloc(sizeof(element));
        tmp->dist = dist+1;
        tmp->x = i;
        tmp->y = j+1;

        priority_queuePush(queue, tmp);
        
        if(i!=labyrinth->end.x || j+1!=labyrinth->end.y)
            labyrinth->at[i][j+1].color = ORANGE;
        labyrinth->at[i][j+1].direction = RIGHT;
        labyrinth->at[i][j+1].dp = dist+1;
    }
    if(i<labyrinth->x_size-1 && labyrinth->at[i][j].south && labyrinth->at[i+1][j].dp<0){
        element* tmp = (element*)malloc(sizeof(element));
        tmp->dist = dist+1;
        tmp->x = i+1;
        tmp->y = j;

        priority_queuePush(queue, tmp);
        
        if(i+1!=labyrinth->end.x || j!=labyrinth->end.y)
            labyrinth->at[i+1][j].color = ORANGE;
        labyrinth->at[i+1][j].direction = DOWN;
        labyrinth->at[i+1][j].dp = dist+1;
    }
    if(j>0 && labyrinth->at[i][j-1].east && labyrinth->at[i][j-1].dp<0){
        element* tmp = (element*)malloc(sizeof(element));
        tmp->dist = dist+1;
        tmp->x = i;
        tmp->y = j-1;

        priority_queuePush(queue, tmp);
        
        if(i!=labyrinth->end.x || j-1!=labyrinth->end.y)
            labyrinth->at[i][j-1].color = ORANGE;
        labyrinth->at[i][j-1].direction = LEFT;
        labyrinth->at[i][j-1].dp = dist+1;
    }   
}