#include "Graph.h"

// Begin : Construction & Deconstruction

	/** Constructor
	 * Creates a new Graph object
	 * 
	 * @param max_points : Maximum number of points in the Graph
	 * @param max_edges : Maximum number of edges in the GRAPH (not the point)
	 */
	Graph::Graph(size_t max_points, size_t max_edges) noexcept 
	{
		all_points = new(std::nothrow) Point[max_points] {};
		all_edges = new(std::nothrow) Edge[max_edges] {};

		if(all_points && all_edges) 
		{
			p_capacity = max_points;
			e_capacity = max_edges;
		}
	}

	/**Deconstruction
	 * NOTE on the '~Graph()':
	 * The ~ flags this block as a deconstructor. It makes it so this runs before the object is removed from memory preventing memory leaks
	 * Find the memory buffers pointed to by all_points and all_edges, and mark that memory as available for other programs to use.
	 * 
	 */
	Graph::~Graph() 
	{
		delete[] all_points;
		delete[] all_edges;
	}

	/** Move Constructor
	 * Instructions to move the current graph object from one memory location to another without copying
	 */
	Graph::Graph(Graph&& other) noexcept
		: all_points(std::exchange(other.all_points, nullptr)),
		all_edges(std::exchange(other.all_edges, nullptr)),
		p_capacity(std::exchange(other.p_capacity, 0)),
		e_capacity(std::exchange(other.e_capacity, 0)) {}
// End : Construction & Deconstruction


// Begin : Getters

	/** Getter Function: get_p_edges
	 * Gets the address of the first edge for Point P at index p_index
	 * 
	 * @param p_index : The index (int) of the point
	 * @returns Edge* : the address of the first edge for p_index
	 * */
	Edge* Graph::get_p_edges(int p_index) noexcept 
	{
		//Checking for for index validity and that the point has edges
		if(p_index < 0 || (size_t)p_index >= p_capacity) return nullptr;

		//assigning the start_point_index to be the first_edge in the points array of edges
		//if it's negative one, there are not edges assigned 
		int start_point_index = all_points[p_index].first_edge;
		if(start_point_index == -1) return nullptr;

		//if there are edges it returns the address of the first edge so that the user can iterate through them like an array
		return &all_edges[start_point_index];
	} 



// Begin : Setters
	/** add_edge
	 * Adds an edge between two points
	 * 
	 * @param start_point_index : the index of the starting point
	 * @param end_point_index : the index of the ending point
	 * 
	 **/
	void Graph::add_edge(int start_point_index, int end_point_index) noexcept 
	{
        if (next_possible_edge >= e_capacity) return; // Buffer full

        // 1. If this is the first edge for this point, record the start index
        if (all_points[start_point_index].e_count == 0) 
		{
            all_points[end_point_index].first_edge = next_possible_edge;
        }

        // 2. Place the edge in the flat buffer
        all_edges[next_possible_edge].target_point = end_point_index;

        // 3. Update counters
        all_points[start_point_index].e_count++;
        next_possible_edge++;
    }

// End : Setters