Main.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>


#include "Functions.h"



typedef struct node
{
    char *first_city; //city_name
    int total_distance;
    struct node *next_node;
    struct list *dest_list;
    struct node *shortest_way;
} node;

typedef struct list
{
    char *second_city; //dest_city_name
    int distance; //single_dist
    struct node *dest_node;
    struct list *next_list_element;
} list;

list* find_last_list_element(list* list_element)
{
    while(list_element->next_list_element!=NULL)
    {
        list_element=list_element->next_list_element;
        return list_element;

    }
    if(list_element==NULL)
    {
        return NULL;
    }
}
node* find_last_node(node* origin)
{
    node* current_node=origin;
    while(current_node->next_node!=NULL)
    {
        current_node=current_node->next_node;
    }
    return current_node;
}

node* find_existing_node(node* origin, char find_cuty[])
{
    while(origin->next_node!=NULL)
    {
    origin=origin->next_node;

        if(origin->first_city==NULL)
        {
            return NULL;
        }
        if(strcmp(origin->first_city,find_cuty)==0)
        {
            return origin;
        }
    }
    return NULL;


}
list* create_new_list(char second_city[], int temp_distance)
{
    list* new_list=(list*)malloc(sizeof(list));
    new_list->next_list_element=NULL;
    new_list->distance=temp_distance;
    new_list->second_city=array_allocation(second_city);
    return new_list;
}
node* create_new_node(char first_city[])
{
    node* new_node =(node*)malloc(sizeof(node));
    new_node->first_city=array_allocation(first_city);
    new_node->shortest_way=NULL;
    new_node->next_node=NULL;
    new_node->dest_list=NULL;
    return new_node;
}

node* create_first_node(node *origin,char first_city[])
{
    origin->first_city=array_allocation(first_city);
    origin->shortest_way=NULL;
    origin->next_node=NULL;
    origin->next_node=NULL;
    return origin;
}

void be_toghether(node *origin, char first_city[], char second_city[], int distance)
{
    node* start_node=find_existing_node(origin,first_city);
    if(start_node==NULL)
    {
        if(origin->first_city==NULL)
        {
            start_node=create_first_node(origin,first_city);
        }
        else
        {
            start_node=create_new_node(first_city);
            node* last_node=find_last_node(origin);
            last_node->next_node=start_node;
        }
    }
    node* dest_node=find_existing_node(origin,second_city);
    if(dest_node==NULL)
    {
        dest_node=create_new_node(second_city);
        node* last_node=find_last_node(origin);
        last_node->next_node=dest_node;
    }
    list* last_list_element=find_last_list_element(start_node->dest_list);
    list* new_list_element;
    new_list_element=create_new_list(second_city,distance);
    new_list_element->dest_node=dest_node;
    if(last_list_element==NULL)
    {
        start_node->dest_list=new_list_element;
    }
    else
    {
        last_list_element->next_list_element=new_list_element;
    }
}

void reset_distance(node* Node)
{
    double inf = INFINITY;
    if(Node!=NULL)
    {
        Node->total_distance=inf;
        Node->shortest_way=NULL;
        reset_distance(Node->next_node);
    }
}

void set_distance_in_nodes(node* start_node, list* list_element)
{
    if(list_element!=NULL)
    {
        node* destination_node=list_element->dest_node;
        if(destination_node->total_distance > start_node->total_distance + list_element->distance)
        {
            destination_node->total_distance = start_node->total_distance + list_element->distance;
            destination_node->shortest_way = start_node;
            set_distance_in_nodes(destination_node,destination_node->dest_list);
        }
        set_distance_in_nodes(start_node,list_element->next_list_element);
    }
}

void set_distance(node* origin, char first_city[])
{
    node* start_node=find_existing_node(origin,first_city);
    if(start_node!=NULL)
    {
        start_node->total_distance=0;
        set_distance_in_nodes(start_node,start_node->dest_list);
    }
}

int scan_i_file(char *road_file_path,node* origin)
{
    FILE* road_file=fopen(road_file_path,"r");
    if(road_file==NULL)
    {
        printf("Couldn't open input file.\n");
        help();
        return 1;
    }
    char first_city[128], second_city[128];
    char *first_city_pointer;
    char *second_city_pointer;
    int single_distance;
    while(!feof(road_file))
    {
        fscanf(road_file,"%s",first_city);
        first_city_pointer=array_allocation(first_city);
        fscanf(road_file,"%s",second_city);
        second_city_pointer=array_allocation(first_city);
        fscanf(road_file,"%d",&single_distance);
        be_toghether(origin,first_city_pointer,second_city_pointer,single_distance);
    }
    fclose(road_file);
    return 0;
}

int print_to_file(node* origin, char first_city[], char second_city[],FILE* output_file)
{

    double inf = INFINITY;
    reset_distance(origin);
    set_distance(origin,first_city);
    node* dest_node=find_existing_node(origin,second_city);

    if(!strcmp(first_city,second_city))
    {
        fprintf(output_file,"\n %s to %s = 0 \n",first_city,second_city);
        return 1;
    }
        if((dest_node==NULL) || (dest_node->total_distance==inf) || (dest_node->total_distance==0))
    {
        fprintf(output_file,"\n %s to %s: \nThere is no route\n",first_city,second_city);
        return 1;
    }

    node* previous_node=dest_node;
    node* prevprev_node=previous_node->shortest_way;
    fprintf(output_file,"\n %s to %s (%d):\n",first_city,second_city,dest_node->total_distance);
    while(prevprev_node!=NULL)
    {

        fprintf(output_file,"%s to %s %d\n",prevprev_node->first_city,previous_node->first_city,previous_node->total_distance-prevprev_node->total_distance);
        previous_node=prevprev_node;
        prevprev_node=previous_node->shortest_way;
    }
}
int print_result(char i_file_path[], char o_file_path[], node* origin,char hq[])
{
    FILE *input_file=fopen(i_file_path,"r");
    if(input_file==NULL)
    {
        printf("FILE ERROR! Couldn't open -t file!\n");
        help();
        return 1;
    }
    FILE *output_file=fopen(o_file_path,"w");
    if(output_file==NULL)
    {
        printf("FILE ERROR! Couldn't open -o file!\n");
        fclose(input_file);
        help();
        return 1;
    }
    char first_city[strlen(hq)+1];
    strcpy(first_city,hq);
    char second_city[128];
    char something[128];
    int bb;
    while(!feof(input_file))
    {
        fscanf(input_file,"%s",something);
        fscanf(input_file,"%s",second_city);
        fscanf(input_file,"%d",&bb);
        print_to_file(origin,first_city,second_city,output_file);
    }
    fclose(input_file);
    fclose(output_file);
    return 0;
}
void free_list(list* list_element)
{
    if(list_element->next_list_element!=NULL)
    {
        free_list(list_element->next_list_element);
        free(list_element->second_city);
    }
    free(list_element);
}

void free_all(node* origin)
{
    if(origin->next_node!=NULL)
    {
        free(origin->first_city);
        free_all(origin->next_node);
    }
    if(origin->dest_list!=NULL)
    {
        free_list(origin->dest_list);
    }
    free(origin);
}
int main(int argc, char **argv)
{
    char *input;
    char *output;
    char *headquarter;
    char hq[128];

    if(console_check(argc,argv,&input,&output,&headquarter)==0)
    {
        return 1;
    }

    node* first_node=(node*)malloc(sizeof(node));
    first_node->dest_list=NULL;
    first_node->next_node=NULL;
    first_node->shortest_way=NULL;
    first_node->first_city=NULL;

    if(scan_i_file(input,first_node)==1)
    {
        return 1;
    }

    print_result(input,output,first_node,hq);

    free_all(first_node);

    return 0;
}