// loc.c written by Mitchell Foral. mitchell<att>caladbolg.net.
// See COPYING for license information.

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

#include "loc.h"

// Loc

Loc *ohcount_loc_new(const char *language, int code, int comments, int blanks,
                     int filecount) {
  Loc *loc = malloc(sizeof(Loc));
  loc->language = language;
  loc->code = code;
  loc->comments = comments;
  loc->blanks = blanks;
  loc->filecount = filecount;
  return loc;
}

int ohcount_loc_total(Loc *loc) {
  return loc->code + loc->comments + loc->blanks;
}

void ohcount_loc_add_loc(Loc *loc, Loc *other) {
  if (strcmp(loc->language, other->language) == 0) {
    loc->code += other->code;
    loc->comments += other->comments;
    loc->blanks += other->blanks;
    loc->filecount += other->filecount;
  }
}

int ohcount_loc_is_equal(Loc *loc, Loc *other) {
  return strcmp(loc->language, other->language) == 0 &&
         loc->code == other->code && loc->comments == other->comments &&
         loc->blanks == other->blanks && loc->filecount == other->filecount;
}

void ohcount_loc_free(Loc *loc) {
  free(loc);
}

// LocList

LocList *ohcount_loc_list_new() {
  LocList *list = malloc(sizeof(LocList));
  list->loc = NULL;
  list->next = NULL;
  list->head = NULL;
  list->tail = NULL;
  return list;
}

void ohcount_loc_list_add_loc(LocList *list, Loc *loc) {
  if (list->head == NULL) { // empty list
    list->head = list;
    list->tail = list;
    list->head->loc = ohcount_loc_new(loc->language, loc->code, loc->comments,
                                      loc->blanks, loc->filecount);
    list->head->next = NULL;
  } else {
    LocList *iter = list->head;
    while (iter) {
      if (iter->loc && strcmp(iter->loc->language, loc->language) == 0) break;
      iter = iter->next;
    }
    if (iter == NULL) { // new language
      LocList *item = ohcount_loc_list_new();
      item->loc = ohcount_loc_new(loc->language, loc->code, loc->comments,
                                  loc->blanks, loc->filecount);
      list->tail->next = item;
      list->tail = item;
    } else ohcount_loc_add_loc(iter->loc, loc); // existing language
  }
}

void ohcount_loc_list_add_loc_list(LocList *list, LocList *other) {
  LocList *iter = other->head;
  while (iter) {
    ohcount_loc_list_add_loc(list, iter->loc);
    iter = iter->next;
  }
}

Loc *ohcount_loc_list_get_loc(LocList *list, const char *language) {
  LocList *iter = list->head;
  while (iter) {
    if (strcmp(iter->loc->language, language) == 0) return iter->loc;
    iter = iter->next;
  }
  return NULL;
}

int ohcount_loc_list_code(LocList *list) {
  int sum = 0;
  LocList *iter = list->head;
  while (iter) {
    sum += iter->loc->code;
    iter = iter->next;
  }
  return sum;
}

int ohcount_loc_list_comments(LocList *list) {
  int sum = 0;
  LocList *iter = list->head;
  while (iter) {
    sum += iter->loc->comments;
    iter = iter->next;
  }
  return sum;
}

int ohcount_loc_list_blanks(LocList *list) {
  int sum = 0;
  LocList *iter = list->head;
  while (iter) {
    sum += iter->loc->blanks;
    iter = iter->next;
  }
  return sum;
}

int ohcount_loc_list_total(LocList *list) {
  int sum = 0;
  LocList *iter = list->head;
  while (iter) {
    sum += ohcount_loc_total(iter->loc);
    iter = iter->next;
  }
  return sum;
}

int ohcount_loc_list_filecount(LocList *list) {
  int sum = 0;
  LocList *iter = list->head;
  while (iter) {
    sum += iter->loc->filecount;
    iter = iter->next;
  }
  return sum;
}

LocList *ohcount_loc_list_new_compact(LocList *list) {
  LocList *new_list = ohcount_loc_list_new();
  LocList *iter = list->head;
  while (iter) {
    if (ohcount_loc_total(iter->loc) != 0)
      ohcount_loc_list_add_loc(new_list, iter->loc);
    iter = iter->next;
  }
  return new_list;
}

void ohcount_loc_list_free(LocList *list) {
  if (list->head) {
    LocList *iter = list->head;
    while (iter) {
      LocList *next = iter->next;
      ohcount_loc_free(iter->loc);
      free(iter);
      iter = next;
    }
  } else free(list);
}

// LocDelta

LocDelta *ohcount_loc_delta_new(const char *language, int code_added,
                                int code_removed, int comments_added,
                                int comments_removed, int blanks_added,
                                int blanks_removed) {
  LocDelta *delta = malloc(sizeof(LocDelta));
  delta->language = language;
  delta->code_added = code_added;
  delta->code_removed = code_removed;
  delta->comments_added = comments_added;
  delta->comments_removed = comments_removed;
  delta->blanks_added = blanks_added;
  delta->blanks_removed = blanks_removed;
  return delta;
}

int ohcount_loc_delta_net_code(LocDelta *delta) {
  return delta->code_added - delta->code_removed;
}

int ohcount_loc_delta_net_comments(LocDelta *delta) {
  return delta->comments_added - delta->comments_removed;
}

int ohcount_loc_delta_net_blanks(LocDelta *delta) {
  return delta->blanks_added - delta->blanks_removed;
}

int ohcount_loc_delta_net_total(LocDelta *delta) {
  return ohcount_loc_delta_net_code(delta) +
         ohcount_loc_delta_net_comments(delta) +
         ohcount_loc_delta_net_blanks(delta);
}

void ohcount_loc_delta_add_loc_delta(LocDelta *delta, LocDelta *other) {
  if (strcmp(delta->language, other->language) == 0) {
    delta->code_added += other->code_added;
    delta->code_removed += other->code_removed;
    delta->comments_added += other->comments_added;
    delta->comments_removed += other->comments_removed;
    delta->blanks_added += other->blanks_added;
    delta->blanks_removed += other->blanks_removed;
  }
}

int ohcount_loc_delta_is_changed(LocDelta *delta) {
  return delta->code_added != 0 || delta->code_removed != 0 ||
         delta->comments_added != 0 || delta->comments_removed != 0 ||
         delta->blanks_added != 0 || delta->blanks_removed != 0;
}

int ohcount_loc_delta_is_equal(LocDelta *delta, LocDelta *other) {
  return strcmp(delta->language, other->language) == 0 &&
         delta->code_added == other->code_added &&
         delta->code_removed == other->code_removed &&
         delta->comments_added == other->comments_added &&
         delta->comments_removed == other->comments_removed &&
         delta->blanks_added == other->blanks_added &&
         delta->blanks_removed == other->blanks_removed;
}

void ohcount_loc_delta_free(LocDelta *delta) {
  free(delta);
}

// LocDeltaList

LocDeltaList *ohcount_loc_delta_list_new() {
  LocDeltaList *list = malloc(sizeof(LocDeltaList));
  list->delta = NULL;
  list->next = NULL;
  list->head = NULL;
  list->tail = NULL;
  return list;
}

void ohcount_loc_delta_list_add_loc_delta(LocDeltaList *list, LocDelta *delta) {
  if (list->head == NULL) { // empty list
    list->head = list;
    list->tail = list;
    list->head->delta = ohcount_loc_delta_new(delta->language,
                                              delta->code_added,
                                              delta->code_removed,
                                              delta->comments_added,
                                              delta->comments_removed,
                                              delta->blanks_added,
                                              delta->blanks_removed);
    list->head->next = NULL;
  } else {
    LocDeltaList *iter = list->head;
    while (iter) {
      if (list->delta && strcmp(list->delta->language, delta->language) == 0) break;
      iter = iter->next;
    }
    if (iter == NULL) { // new language
      LocDeltaList *item = ohcount_loc_delta_list_new();
      item->delta = ohcount_loc_delta_new(delta->language,
                                          delta->code_added,
                                          delta->code_removed,
                                          delta->comments_added,
                                          delta->comments_removed,
                                          delta->blanks_added,
                                          delta->blanks_removed);
      list->tail->next = item;
      list->tail = item;
    } else ohcount_loc_delta_add_loc_delta(iter->delta, delta); // existing
  }
}

void ohcount_loc_delta_list_add_loc_delta_list(LocDeltaList *list,
                                               LocDeltaList *loc_delta_list) {
  LocDeltaList *iter = loc_delta_list->head;
  while (iter) {
    ohcount_loc_delta_list_add_loc_delta(list, iter->delta);
    iter = iter->next;
  }
}

LocDelta *ohcount_loc_delta_list_get_loc_delta(LocDeltaList *list,
                                               const char *language) {
  LocDeltaList *iter = list->head;
  while (iter) {
    if (strcmp(iter->delta->language, language) == 0) return iter->delta;
    iter = iter->next;
  }
  return NULL;
}

int ohcount_loc_delta_list_code_added(LocDeltaList *list) {
  int sum = 0;
  LocDeltaList *iter = list->head;
  while (iter) {
    sum += iter->delta->code_added;
    iter = iter->next;
  }
  return sum;
}

int ohcount_loc_delta_list_code_removed(LocDeltaList *list) {
  int sum = 0;
  LocDeltaList *iter = list->head;
  while (iter) {
    sum += iter->delta->code_removed;
    iter = iter->next;
  }
  return sum;
}

int ohcount_loc_delta_list_comments_added(LocDeltaList *list) {
  int sum = 0;
  LocDeltaList *iter = list->head;
  while (iter) {
    sum += iter->delta->comments_added;
    iter = iter->next;
  }
  return sum;
}

int ohcount_loc_delta_list_comments_removed(LocDeltaList *list) {
  int sum = 0;
  LocDeltaList *iter = list->head;
  while (iter) {
    sum += iter->delta->comments_removed;
    iter = iter->next;
  }
  return sum;
}

int ohcount_loc_delta_list_blanks_added(LocDeltaList *list) {
  int sum = 0;
  LocDeltaList *iter = list->head;
  while (iter) {
    sum += iter->delta->blanks_added;
    iter = iter->next;
  }
  return sum;
}

int ohcount_loc_delta_list_blanks_removed(LocDeltaList *list) {
  int sum = 0;
  LocDeltaList *iter = list->head;
  while (iter) {
    sum += iter->delta->blanks_removed;
    iter = iter->next;
  }
  return sum;
}

int ohcount_loc_delta_list_net_code(LocDeltaList *list) {
  int sum = 0;
  LocDeltaList *iter = list->head;
  while (iter) {
    sum += ohcount_loc_delta_net_code(iter->delta);
    iter = iter->next;
  }
  return sum;
}

int ohcount_loc_delta_list_net_comments(LocDeltaList *list) {
  int sum = 0;
  LocDeltaList *iter = list->head;
  while (iter) {
    sum += ohcount_loc_delta_net_comments(iter->delta);
    iter = iter->next;
  }
  return sum;
}

int ohcount_loc_delta_list_net_blanks(LocDeltaList *list) {
  int sum = 0;
  LocDeltaList *iter = list->head;
  while (iter) {
    sum += ohcount_loc_delta_net_blanks(iter->delta);
    iter = iter->next;
  }
  return sum;
}

int ohcount_loc_delta_list_net_total(LocDeltaList *list) {
  int sum = 0;
  LocDeltaList *iter = list->head;
  while (iter) {
    sum += ohcount_loc_delta_net_total(iter->delta);
    iter = iter->next;
  }
  return sum;
}

LocDeltaList *ohcount_loc_delta_list_new_compact(LocDeltaList *list) {
  LocDeltaList *new_list = ohcount_loc_delta_list_new();
  LocDeltaList *iter = list->head;
  while (iter) {
    if (ohcount_loc_delta_is_changed(iter->delta))
      ohcount_loc_delta_list_add_loc_delta(new_list, iter->delta);
    iter = iter->next;
  }
  return new_list;
}

void ohcount_loc_delta_list_free(LocDeltaList *list) {
  if (list->head) {
    LocDeltaList *iter = list->head;
    while (iter) {
      LocDeltaList *next = iter->next;
      ohcount_loc_delta_free(iter->delta);
      free(iter);
      iter = next;
    }
  } else free(list);
}