#ifndef RR_GRAPH_CLOCK_H
#define RR_GRAPH_CLOCK_H

#include <string>
#include <vector>
#include <memory>
#include <unordered_map>
#include <set>
#include <utility>

#include "clock_fwd.h"

#include "clock_network_builders.h"
#include "clock_connection_builders.h"

class ClockNetwork;
class ClockConnection;

class SwitchPoint {
    /* A switch point object: keeps information on the location and and rr_node indices
       for a certain clock switch. clock connections are grouped with their own unique
       name; this object holds information for only one such grouping.
       Examples of SwitchPoint(s) are rib-to-spine, driver-to-spine. */
    public:
        // [grid_width][grid_height][0..nodes_at_this_location-1]
        std::vector<std::vector<std::vector<int>>> rr_node_indices;
        // Set of all the locations for this switch point. Used to quickly find
        // if the switch point exists at a certian location.
        std::set<std::pair<int, int>> locations; // x,y
    public:
        /** Getters **/
        std::vector<int> get_rr_node_indices_at_location(int x, int y) const;

        std::set<std::pair<int, int>> get_switch_locations() const;

        /** Setters **/
        void insert_node_idx(int x, int y, int node_idx);
};

class SwitchPoints {
    /* This Class holds a map from a uniquely named switch to all of its locations on
       the device and its rr_node_indices. The location and rr_node_indices are stored
       in the SwitchPoint object*/
    public:
        std::unordered_map<std::string, SwitchPoint> switch_point_name_to_switch_location;
    public:
        /** Getters **/

        /* Example: x,y = middle of the chip, switch_point_name == name of main drive
           of global clock spine, returns the rr_nodes of all the clock spines that
           start the newtork there*/
        std::vector<int> get_rr_node_indices_at_location(
            std::string switch_point_name,
            int x,
            int y) const;

        std::set<std::pair<int, int>> get_switch_locations(std::string switch_point_name) const;

        /** Setters **/
        void insert_switch_node_idx(std::string switch_point_name, int x, int y, int node_idx);
};

class ClockRRGraphBuilder {

    public:
        /* Returns the current ptc num where the wire should be drawn and updates the
           channel width. Note: The ptc_num is determined by the channel width. The channel
           width global state gets incremented everytime there is a request for a new ptc_num*/
        int get_and_increment_chanx_ptc_num();
        int get_and_increment_chany_ptc_num();


    public:
        /* Reverse lookup for to find the clock source and tap locations for each clock_network
           The map key is the the clock network name and value are all the switch points*/
        std::unordered_map<std::string, SwitchPoints> clock_name_to_switch_points;

        /* Saves a map from switch rr_node idx -> {x, y} location */
        void add_switch_location(
            std::string clock_name,
            std::string switch_point_name,
            int x,
            int y,
            int node_index);

        /* Returns the rr_node idx of the switch at location {x, y} */
        std::vector<int> get_rr_node_indices_at_switch_location(
            std::string clock_name,
            std::string switch_point_name,
            int x,
            int y) const;

        /* Returns all the switch locations for the a certain clock network switch */
        std::set<std::pair<int, int>> get_switch_locations(
            std::string clock_name,
            std::string switch_point_name) const;

    public:
        /* Creates the routing resourse (rr) graph of the clock network and appends it to the
           existing rr graph created in build_rr_graph for inter-block and intra-block routing. */
        static void create_and_append_clock_rr_graph(
                std::vector<t_segment_inf>& segment_inf,
                const float R_minW_nmos,
                const float R_minW_pmos,
                int wire_to_rr_ipin_switch,
                const enum e_base_cost_type base_cost_type);

    private:
        /* loop over all of the clock networks and create their wires */
        void create_clock_networks_wires(
            std::vector<std::unique_ptr<ClockNetwork>>& clock_networks,
            int num_segments);

        /* loop over all clock routing connections and create the switches and connections */
        void create_clock_networks_switches(
            std::vector<std::unique_ptr<ClockConnection>>& clock_connections);

        /* Adds the architecture switches that the clock rr_nodes use to the rr switches and
           maps the newly added rr_switches to the nodes.
           The input nodes_start_idx ~ corresponds to the rr_node index of the first node
           used to create the clock network. Every node from node_start_idx..rr_nodes.size-1
           is a node in the clock network.*/
        // TODO: Change to account for swtich fanin. Note: this function is simular to
        //       remap_rr_node_switch_indices but does not take into account node fanin.
        void add_rr_switches_and_map_to_nodes(
                size_t nodes_start_idx,
                const float R_minW_nmos,
                const float R_minW_pmos);

        /* Returns the index of the newly added rr_switch. The rr_switch information is coppied
           in from the arch_switch information */
        // TODO: Does not account for fanin information when copping Tdel. Note: this function
        //       is simular to load_rr_switch_inf but does not take into account node fanin.
        int add_rr_switch_from_arch_switch_inf(
                int arch_switch_idx,
                const float R_minW_nmos,
                const float R_minW_pmos);
};

#endif