#include "profile_lookahead.h"

using namespace std;

void print_start_end_to_sink(bool is_start, int itry, int inet, int target_node, int itarget) {
    if (itry == DB_ITRY && target_node == DB_TARGET_NODE){
        if (is_start) {
            printf("\n**** itry %d\tSTART ROUTE TO net %d\ttarget %d\tinode %d\n", 
                    itry, inet, itarget, target_node);
            printf("COORD: (%d,%d)\n", rr_node[target_node].get_xlow(), rr_node[target_node].get_ylow());
        } else {
            printf("\n**** itry %d\tFINISH ROUTE TO net %d\ttarget %d\tinode %d\n\n", 
                    itry, inet, itarget, target_node);
        }
    } 
}

void print_expand_neighbours(bool is_parent, int inode, int target_node, 
    int target_chan_type, int target_pin_x, int target_pin_y, 
    float expected_cost, float future_Tdel, float new_tot_cost, 
    float cur_basecost, float cong_cost) {
    if (itry_share == DB_ITRY && target_node == DB_TARGET_NODE) {
        const char *dir_name[] = {"INC", "DEC", NULL};
        const char *node_seg_type[] = {"source", "sink", "ipin", "opin", "chanX", "chanY", NULL};   
        int dir = (rr_node[inode].get_direction() == INC_DIRECTION) ? 0 : 1;
        int inode_type = rr_node[inode].type;
        int inode_seg_index = rr_indexed_data[rr_node[inode].get_cost_index()].seg_index;
        float basecost, C, Tdel;
        int s_x, s_y, e_x, e_y, len;
        get_unidir_seg_start(inode, &s_x, &s_y);
        get_unidir_seg_end(inode, &e_x, &e_y);
        len = rr_node[inode].get_len();
        if (is_parent) {
            if (target_chan_type == UNDEFINED) {
                printf("TARGET CHAN TYPE UNDEFINED\n");
            } else {
                printf("TARGET CHAN TYPE: %d\tX %d\tY %d\n", target_chan_type, target_pin_x, target_pin_y);
            }
            Tdel = get_timing_driven_future_Tdel(inode, target_node, &C, &basecost);
            printf("EXPAND inode %d(L%d)\t%s\t%s-%d\t(%d,%d)\t(%d,%d)\tpath cost %.3f\texp cost %.3f\n",
                inode, len, dir_name[dir], node_seg_type[inode_type],
                inode_seg_index, s_x, s_y, e_x, e_y, 
                rr_node_route_inf[inode].path_cost * pow(10, 10),
                Tdel * pow(10, 10) );
        } else {
            printf("\texpand %d(L%d)\t%s\t%s-%d\t(%d,%d)\t(%d,%d)\t",
                inode, len, dir_name[dir], node_seg_type[inode_type], 
                inode_seg_index, s_x, s_y, e_x, e_y);
            printf("exp cost %.3f\tb-Tdel %.3f\ttot cost %.3f\tbCost %.3fcCost %.3f\n",
                expected_cost * pow(10, 10), future_Tdel * pow(10, 10),
                new_tot_cost * pow(10, 10), cur_basecost * pow(10, 10),
                cong_cost * pow(10, 10));
        }
    }
}

void setup_max_min_criticality(float &max_crit, float &min_crit, 
        int &max_inet, int &min_inet, int &max_ipin, int &min_ipin, t_slack * slacks) {
    /*
     *  set up max/min criticality && where the max/min happens
     *  called in try_timing_driven_route()
     */
    float max_crit_len_product = -1;
    float min_crit_len_product = pow(10, 20);
    max_crit = -1;
    min_crit = pow(10, 20);
    max_inet = -1;
    max_ipin = -1;
    min_inet = -1;
    min_ipin = -1;
    for (unsigned int inet = 0; inet < g_clbs_nlist.net.size(); ++inet) {
        if (should_route_net(inet) == false)
            continue; 
        if (g_clbs_nlist.net[inet].is_global == true)
            continue;
        if (g_clbs_nlist.net[inet].is_fixed == true)
            continue;
        int source_inode = net_rr_terminals[inet][0];
        int x_source_mid = (rr_node[source_inode].get_xhigh() + rr_node[source_inode].get_xlow()) / 2;
        int y_source_mid = (rr_node[source_inode].get_yhigh() + rr_node[source_inode].get_ylow()) / 2;
        unsigned int pin_upbound = (g_clbs_nlist.net[inet].pins.size() > 2) ? 2 : g_clbs_nlist.net[inet].pins.size();
        for (unsigned int ipin = 1; ipin < pin_upbound; ipin++) {
            float pin_criticality = slacks->timing_criticality[inet][ipin];
            int target_inode = net_rr_terminals[inet][ipin];
            int x_target_mid = (rr_node[target_inode].get_xhigh() + rr_node[target_inode].get_xlow()) / 2;
            int y_target_mid = (rr_node[target_inode].get_yhigh() + rr_node[target_inode].get_ylow()) / 2;
            // print long nets only
            int bb_len = abs(x_source_mid - x_target_mid + 1) + abs(y_source_mid - y_target_mid + 1);
            float len_crit_product = bb_len * pin_criticality;
            float len_inv_crit_product = (1./bb_len) * pin_criticality;
            max_inet = (len_crit_product > max_crit_len_product) ? inet : max_inet;
            max_ipin = (len_crit_product > max_crit_len_product) ? ipin : max_ipin;
            min_inet = (len_inv_crit_product < min_crit_len_product) ? inet : min_inet;
            min_ipin = (len_inv_crit_product < min_crit_len_product) ? ipin : min_ipin;
            max_crit = (len_crit_product > max_crit_len_product) ? pin_criticality : max_crit;
            min_crit = (len_inv_crit_product < min_crit_len_product) ? pin_criticality : min_crit;
            max_crit_len_product = (len_crit_product > max_crit_len_product) ? len_crit_product : max_crit_len_product;
            min_crit_len_product = (len_inv_crit_product < min_crit_len_product) ? len_inv_crit_product : min_crit_len_product;
        }
    }
    //printf("max_inet %d\tmax_ipin %d\tmin_inet %d\tmin_ipin %d\n", max_inet, max_ipin, min_inet, min_ipin);
    //printf("max_crit_len_product %f\tmin_crit %f\n", max_crit_len_product, min_crit);
    //printf("\n");

}

void print_critical_path_from_rt(struct s_heap *hptr, float target_criticality, int new_nodes_count, float actual_Tdel) {
    int target_node = hptr->index;
    if (target_node == DB_TARGET_NODE && itry_share == DB_ITRY) {
        int inode = hptr->u.prev_node;
        printf("CRITICAL PATH %d: back trace start\tcrit: %fNEW NODES %d\n", target_node, target_criticality, new_nodes_count);
        while (rr_node_route_inf[inode].prev_node != NO_PREVIOUS) {
            // this is backtrace, so print in anti-direction order
            int ix_s, ix_e, iy_s, iy_e;
            get_unidir_seg_end(inode, &ix_s, &iy_s);
            get_unidir_seg_start(inode, &ix_e, &iy_e);
            int prev_inode = rr_node_route_inf[inode].prev_node;
            float bTdel = rr_node_route_inf[inode].back_Tdel;
            float bbTdel = rr_node_route_inf[prev_inode].back_Tdel;
            int wire_type = rr_indexed_data[rr_node[inode].get_cost_index()].seg_index;
            float dummy, basecost = 0;
            printf("\tid:%d - %d\tstart(%d,%d)\tend(%d,%d)\tbackTdel:%einodeTdel:%e\tactual future Tdel:%.3f\test future Tdel:%.3f\n", 
                    inode, wire_type, ix_s, iy_s, ix_e, iy_e,
                    bTdel, (bTdel - bbTdel), 
                    (actual_Tdel - bTdel) * pow(10, 10), 
                    get_timing_driven_future_Tdel(inode, target_node, &dummy, &basecost) * pow(10, 10));
            inode = prev_inode;
        }
    }
}

void setup_new_lookahead_dev(int furthest_wire_inode, int target_node, float total_Tdel, int new_nodes_count) {
    /*
    float estimated_future_cost = rr_node_route_inf[inode].path_cost 
                            - rr_node_route_inf[inode].backward_path_cost;
    float actual_future_cost = actual_tot_cost 
                            - rr_node_route_inf[inode].backward_path_cost;
    */
    float new_nodes_dev = 0.;
    float estimated_future_cost, actual_future_cost;
    float c_downstream, basecost;
    estimated_future_cost = get_timing_driven_future_Tdel(furthest_wire_inode, target_node, &c_downstream, &basecost);
    actual_future_cost = total_Tdel - rr_node_route_inf[furthest_wire_inode].back_Tdel;

    if (subtree_count.count(new_nodes_count) <= 0) {
        subtree_count[new_nodes_count] = 0;
        subtree_size_avg[new_nodes_count] = 0;
        subtree_est_dev_avg[new_nodes_count] = 0;
    }
    if (actual_future_cost != 0) {
        new_nodes_dev = (estimated_future_cost / actual_future_cost - 1);
    }
    subtree_count[new_nodes_count] ++;
    int tree_counter = subtree_count[new_nodes_count];
    // running avg: geo mean for subtree size; arithmetic mean for dev
    if (subtree_size_avg[new_nodes_count] == 0) {
        subtree_size_avg[new_nodes_count] = subtree_size_avg[0];
    } else {
        float temp = pow(subtree_size_avg[new_nodes_count], (tree_counter - 1) / (float)tree_counter);
        subtree_size_avg[new_nodes_count] = temp * pow(subtree_size_avg[0], 1.0/(float)tree_counter);
    }
    if (target_node == DB_TARGET_NODE) {
        print_db_node_inf(DB_TARGET_NODE);
    }
    float cur_dev = new_nodes_dev;
    if (cur_dev < -0.6 && new_nodes_count > 10)
        printf("\nXXXXX TARGET NODE %d\n\n", target_node);
    subtree_est_dev_avg[new_nodes_count] = ((tree_counter - 1) * subtree_est_dev_avg[new_nodes_count]
                                    + cur_dev) / (float)tree_counter;
}