loadingdock.cpp

#include "loadingdock.hpp"

LoadingDock::LoadingDock(const LoadingDock & rhs){
  this->ship_fleet = rhs.ship_fleet;
  this->all_types_ship_fleet = rhs.all_types_ship_fleet;
  this->routes = rhs.routes;
  this->all_cargo = rhs.all_cargo;
}

LoadingDock & LoadingDock::operator=(const LoadingDock & rhs){
  if(this != &rhs){
    LoadingDock temp(rhs);
    std::swap(ship_fleet, temp.ship_fleet);
    std::swap(all_types_ship_fleet, temp.all_types_ship_fleet);
    std::swap(routes, temp.routes);
    std::swap(all_cargo, temp.all_cargo);
  }
  return *this;
} 

LoadingDock::~LoadingDock() {
  for (size_t i = 0; i < all_types_ship_fleet.size(); i++) {
    delete all_types_ship_fleet[i];
  }
}

LoadingDock::LoadingDock(char * file_ship, char * file_cargo) {
  parseFileShip(file_ship);
  parseFileCargo(file_cargo);
}

LoadingDock::LoadingDock(char * file_ship) {
  parseFileShip(file_ship);
  printRoutes();
}

void LoadingDock::parseFileShip(char * file_ship) {
  std::ifstream file(file_ship);
  if (file.is_open()) {
    std::string line;

    while (getline(file, line)) {
      Ship temp_ship(line);
      if (!checkName(temp_ship.getName(), ship_fleet)) {
        this->ship_fleet.push_back(temp_ship);
      }
      else {
        std::cerr << "Ship has the same name of ship in the fleet" << std::endl;
        exit(EXIT_FAILURE);
      }

      Route temp_route(temp_ship.getSourceShip(),
                       temp_ship.getDestinationShip(),
                       temp_ship.getTotalCapacityShip());

      int route_index = checkRoute(temp_route, routes);

      if (route_index == -1) {
        routes.push_back(temp_route);
      }
      else {
        routes[route_index].addCapacity(temp_ship.getTotalCapacityShip());
      }
    }
  }
  else {
    std::cerr << "Error opening file." << std::endl;
    exit(EXIT_FAILURE);
  }
  file.close();

  std::sort(routes.begin(), routes.end());
}

void LoadingDock::printRoutes() {
  for (size_t i = 0; i < routes.size(); i++) {
    std::cout << routes[i];
  }
}

void LoadingDock::parseFileCargo(char * file_cargo) {
  std::ifstream file(file_cargo);
  if (file.is_open()) {
    std::string line;
    while (getline(file, line)) {
      Cargo temp_cargo(line);
      this->all_cargo.push_back(temp_cargo);
    }
  }
  else {
    std::cerr << "Error opening file." << std::endl;
    exit(EXIT_FAILURE);
  }
  file.close();
}

std::vector<std::string> LoadingDock::seperateElements(std::string line) {
  std::string delim = ",";
  std::vector<std::string> elements;
  size_t index = 0;
  std::string token;

  std::string line_edit = line;

  while ((index = line_edit.find(delim)) != std::string::npos) {
    token = line_edit.substr(0, index);
    elements.push_back(token);
    line_edit.erase(0, index + delim.length());
  }
  if (!line_edit.empty()) {
    elements.push_back(line_edit);
  }
  return elements;
}

//creates ship objects with the type Container, Tanker, or Animal for dynamic dispatch 
void LoadingDock::findShipType() {
  for (size_t i = 0; i < ship_fleet.size(); i++) {
    std::string type_info = ship_fleet[i].getTypeInfo();
    std::string ship_type = ship_fleet[i].checkTypeInfo(type_info);
    std::vector<std::string> elem = seperateElements(type_info);

    std::string name = ship_fleet[i].getName();
    std::string source = ship_fleet[i].getSourceShip();
    std::string dest = ship_fleet[i].getDestinationShip();
    unsigned long tc = ship_fleet[i].getTotalCapacityShip();
    std::vector<Cargo> cos = ship_fleet[i].getCargoOnShip();
    std::vector<std::string> hm = ship_fleet[i].getHazards();

    if (ship_type.compare("Container") == 0) {
      unsigned long slot = 0;
      if(elem.size() < 2){
        std::cerr << "not enough input for container ship" << std::endl;
        exit(EXIT_FAILURE);
      }
      
      char * endptr;
      const char * slots_string = elem[1].c_str();
      slot = strtoul(slots_string, &endptr, 10);
      
      if(slots_string == endptr) {
        std::cerr << "Invalid argument for slot size, conversion failed" << std::endl;
        exit(EXIT_FAILURE);
      }

      Ship * temp_c = new Container(name, type_info, source, dest, tc, cos, hm, slot);
      temp_c->setShipType("Container");

      if (elem.size() >= 3) {
        for (size_t i = 2; i < elem.size(); i++) {
          temp_c->addHazards(elem[i]);
        }
      }
      all_types_ship_fleet.push_back(temp_c);
    }
    else if (ship_type.compare("Tanker") == 0) {
      signed int min = 0;
      signed int max = 0;
      unsigned int numTanks = 0;

      if(elem.size() < 4){
        std::cerr << "not enough input for tanker ship" << std::endl;
        exit(EXIT_FAILURE);
      }

      min = atoi(elem[1].c_str());
      max = atoi(elem[2].c_str());

      try {
        char * endptr;
        numTanks = strtoul(elem[3].c_str(), &endptr, 10);
      }
      catch (const std::exception & e) {
        std::cerr << "Invalid argument for number of tanks, for ship: " << std::endl;
        exit(EXIT_FAILURE);
      }

      unsigned int cap_per_tank = 0;

      if (tc % numTanks != 0) {
        std::cerr << "Total capacity is not a multiple of number of tanks, for ship: "
                  << name << " total capacity = " << tc << " and num tanks = " << numTanks
                  << std::endl;
        exit(EXIT_FAILURE);
      }
      else {
        cap_per_tank = tc / numTanks;
      }

      Ship * temp_tank = new Tanker(
          name, type_info, source, dest, tc, cos, hm, min, max, numTanks, cap_per_tank);
      temp_tank->initCargoInTankVector();
      temp_tank->setShipType("Tanker");
      if (elem.size() >= 5) {
        for (size_t i = 4; i < elem.size(); i++) {
          temp_tank->addHazards(elem[i]);
        }
      }
      all_types_ship_fleet.push_back(temp_tank);
    }
    else if (ship_type.compare("Animals") == 0) {
      if (elem.size() != 2) {
        std::cerr << "incorrect number of inputs for animal ship" << std::endl;
        exit(EXIT_FAILURE);
      }

      unsigned int smallEnough = 0;

      try {
        char * endptr;
        smallEnough = strtoul(elem[1].c_str(), &endptr, 10);
      }
      catch (const std::exception & e) {
        std::cerr << "Invalid argument for small enough in animal ship" << std::endl;
        exit(EXIT_FAILURE);
      }

      Ship * temp_animal =
          new Animal(name, type_info, source, dest, tc, cos, hm, smallEnough);

      temp_animal->setShipType("Animals");
      all_types_ship_fleet.push_back(temp_animal);
    }
  }
}

bool LoadingDock::checkName(std::string name, std::vector<Ship> ships) {
  if (ships.size() == 0) {
    return false;
  }
  else {
    for (size_t i = 0; i < ships.size(); i++) {
      if (name == ships[i].getName()) {
        return true;
      }
    }
  }
  return false;
}

int LoadingDock::checkRoute(const Route & temp_route, std::vector<Route> routes) {
  if (routes.size() > 0) {
    for (size_t i = 0; i < routes.size(); i++) {
      if (temp_route.getSource() == routes[i].getSource()) {
        if (temp_route.getDestination() == routes[i].getDestination()) {
          return i;
        }
      }
    }
  }
  return -1;
}

void LoadingDock::loadCargo() {
  findShipType();

  std::vector<Ship *> fleet_alphabetical = all_types_ship_fleet;

  std::sort(fleet_alphabetical.begin(), fleet_alphabetical.end(), customOp);

  for (size_t i = 0; i < all_cargo.size(); i++) {
    std::vector<Ship *> possible_ships;
    for (size_t j = 0; j < fleet_alphabetical.size(); j++) {
      if (fleet_alphabetical[j]->matchCargo(all_cargo[i]) == true) {
        possible_ships.push_back(fleet_alphabetical[j]);
      }
    }

    if (possible_ships.size() == 0) {
    }

    printPossibleCargo(possible_ships, all_cargo[i]);
  }

  std::cout << "---Done Loading---Here are the ships---" << std::endl;
  printAllShips(this->all_types_ship_fleet);
}

void LoadingDock::printAllShips(std::vector<Ship *> all_types_fleet) {
  for (size_t j = 0; j < all_types_fleet.size(); j++) {
    std::cout << "The " << (*all_types_fleet[j]).getShipType() << " Ship "
              << (*all_types_fleet[j]).getName() << "("
              << (*all_types_fleet[j]).getUsedCapacityShip() << "/"
              << (*all_types_fleet[j]).getTotalCapacityShip()
              << ") is carrying : " << std::endl;

    if ((*all_types_fleet[j]).getCargoOnShip().size() != 0) {
      std::vector<Cargo> cargo_s = (*all_types_fleet[j]).getCargoOnShip();
      printCargo(cargo_s);
    }
    if ((*all_types_fleet[j]).getShipType().compare("Container") == 0) {
      std::cout << "  (" << (*all_types_fleet[j]).getSlots() << ") slots remain"
                << std::endl;
    }
    else if ((*all_types_fleet[j]).getShipType().compare("Tanker") == 0) {
      std::cout << "  " << (*all_types_fleet[j]).getNumUsedTank() << " / "
                << (*all_types_fleet[j]).getNumTanks() << " tanks used" << std::endl;
    }
    else if ((*all_types_fleet[j]).getShipType().compare("Animals") == 0) {
      if ((*all_types_fleet[j]).hasRoamer() == true) {
        std::cout << "  has a roamer" << std::endl;
      }
      else {
        std::cout << "  does not have a roamer" << std::endl;
      }
    }
  }
}

void LoadingDock::printCargo(std::vector<Cargo> & cargo_ship) {
  for (size_t i = 0; i < cargo_ship.size(); i++) {
    std::cout << "  " << cargo_ship[i].getName() << "(" << cargo_ship[i].getWeight()
              << ")" << std::endl;
  }
}

void LoadingDock::printPossibleCargo(std::vector<Ship *> cargo_ship_match,
                                     const Cargo & cargo_obj) {
  if (cargo_ship_match.size() == 0) {
    std::cout << "No ships can carry the " << cargo_obj.getName() << " from "
              << cargo_obj.getSource() << " to " << cargo_obj.getDestination()
              << std::endl;
  }
  else {
    std::cout << cargo_ship_match.size() << " ships can carry the " << cargo_obj.getName()
              << " from " << cargo_obj.getSource() << " to " << cargo_obj.getDestination()
              << std::endl;
    for (size_t i = 0; i < cargo_ship_match.size(); i++) {
      std::cout << "  " << (*cargo_ship_match[i]).getName() << std::endl;
    }
    std::cout << "  **Loading the cargo onto " << (*cargo_ship_match[0]).getName() << "**"
              << std::endl;
    (*cargo_ship_match[0]).addCargo(cargo_obj);
  }
}

/* loops through the set passed in and checks if the cargo can be loaded on to any of the ships
  in the set. If 2 ships can take the cargo, the names are compared for alphabetical order
  if no ship can take the cargo, the function returns NULL
*/
Ship * LoadingDock::setProcessing(std::set<Ship *, std::less<Ship *> > * potential_ship,
                                  const Cargo & cargo_obj) {
  Ship * curr_ans = NULL;

  for (std::set<Ship *>::iterator it = potential_ship->begin();
       it != potential_ship->end();
       ++it) {
    Ship * temp = const_cast<Ship *>(*it);
    if (temp->matchCargo(cargo_obj) == true) {
      if (curr_ans == NULL) {
        curr_ans = *it;
      }
      else {
        std::string ship1_name = curr_ans->getName();
        std::string ship2_name = temp->getName();
        int result = ship1_name.compare(ship2_name);
        if (result > 0) {
          curr_ans = *it;
        }
      }
    }
  }
  if (curr_ans != NULL) {
    return const_cast<Ship *>(curr_ans);
  }
  return curr_ans;
}

/* this function stable sorts the cargo by weight, then adds all of the Ships into an AVL Tree
  It then loops through the cargo and find the node in the AVL Tree that has a reamining capacity 
  closest (>=) to the weight of the cargo. If NULL is returned then no match is found
  if a set is returned, we then process the set to run cargo ship match rules. If that returns NULL 
  then we look for the next largest value until we get an answer or NULL (cargo does not have a match)
  we then print in the formatted output whether there was a match or not 
*/
void LoadingDock::bestFit() {
  findShipType();

  std::vector<Cargo> cargo_sorted_largest_smallest = this->all_cargo;
  std::stable_sort(cargo_sorted_largest_smallest.begin(),
                   cargo_sorted_largest_smallest.end(),
                   customOp_cargo);

  AVLMultiMap<unsigned long, Ship *> avl_tree_ship_fleet;

  for (size_t i = 0; i < all_types_ship_fleet.size(); i++) {
    avl_tree_ship_fleet.add(all_types_ship_fleet[i]->getRemainingCapacityShip(),
                            all_types_ship_fleet[i]);
  }

  bool match_found = false;

  std::set<Ship *, std::less<Ship *> > * ans_best;
  Ship * match_ship_cargo;

  for (size_t i = 0; i < cargo_sorted_largest_smallest.size(); i++) {
    ans_best = avl_tree_ship_fleet.findBest(cargo_sorted_largest_smallest[i].getWeight());
    if (ans_best != NULL) {
      match_ship_cargo = setProcessing(ans_best, cargo_sorted_largest_smallest[i]);
      while (match_ship_cargo == NULL) {
        if (ans_best != NULL) {
          unsigned long newWeight =
              const_cast<Ship *>(*ans_best->begin())->getRemainingCapacityShip();

          ans_best = avl_tree_ship_fleet.nextLargest(newWeight);
          if (ans_best == NULL) {
            match_found = false;
            break;
          }
          else {
            match_ship_cargo = setProcessing(ans_best, cargo_sorted_largest_smallest[i]);
          }
        }
      }
      if (match_ship_cargo != NULL) {
        match_found = true;
      }
    }
    else if (ans_best == NULL) {
      match_found = false;
    }

    if (match_found == true) {
      avl_tree_ship_fleet.remove(match_ship_cargo->getRemainingCapacityShip(),
                                 match_ship_cargo);
      (*match_ship_cargo).addCargo(cargo_sorted_largest_smallest[i]);
      avlMatchPrint(match_ship_cargo, cargo_sorted_largest_smallest[i]);
      avl_tree_ship_fleet.add(match_ship_cargo->getRemainingCapacityShip(),
                              match_ship_cargo);
    }
    else {
      avlNoMatchPrint(cargo_sorted_largest_smallest[i]);
    }
  }
  std::cout << "---Done Loading---Here are the ships---" << std::endl;
  printAllShips(this->all_types_ship_fleet);
}

void LoadingDock::avlMatchPrint(Ship * ship_obj, const Cargo & cargo_obj) {
  std::cout << "Loading " << cargo_obj.getName() << " onto " << ship_obj->getName()
            << " from " << cargo_obj.getSource() << " to " << cargo_obj.getDestination()
            << " " << ship_obj->getRemainingCapacityShip() << " capacity remains"
            << std::endl;
}

void LoadingDock::avlNoMatchPrint(const Cargo & cargo_obj) {
  std::cout << "No ships can carry the " << cargo_obj.getName() << " from "
            << cargo_obj.getSource() << " to " << cargo_obj.getDestination() << std::endl;
}