#include <assert.h>
#include "util.h"
#include "vpr_types.h"
#include "globals.h"
#include "OptionTokens.h"
#include "ReadOptions.h"
#include "read_xml_arch_file.h"
#include "SetupVPR.h"

/******** Function Prototypes ********/

static void ShowPlacerOpts(INP t_options Options,
			   INP struct s_placer_opts PlacerOpts,
			   INP struct s_annealing_sched AnnealSched);
static void ShowOperation(INP enum e_operation Operation);
static void ShowRouterOpts(INP struct s_router_opts RouterOpts);
static void ShowAnnealSched(INP struct s_annealing_sched AnnealSched);
static void ShowRoutingArch(INP struct s_det_routing_arch RoutingArch);


/******** Function Implementations ********/

void
ShowSetup(INP t_options Options,
	  INP t_arch Arch,
	  INP boolean TimingEnabled,
	  INP enum e_operation Operation,
	  INP struct s_file_name_opts FileNameOpts,
	  INP struct s_placer_opts PlacerOpts,
	  INP struct s_annealing_sched AnnealSched,
	  INP struct s_router_opts RouterOpts,
	  INP struct s_det_routing_arch RoutingArch,
	  INP t_segment_inf * Segments,
	  INP t_timing_inf Timing)
{
    int i, j, num_p_inputs, num_p_outputs;
	int *num_blocks_type; 
	num_blocks_type = my_calloc(num_types, sizeof(int));

    printf("Timing analysis: %s\n", (TimingEnabled ? "ON" : "OFF"));
    printf("\n");

	printf("Circuit netlist file: %s\n", FileNameOpts.NetFile);
	printf("Circuit placement file: %s\n", FileNameOpts.PlaceFile);
	printf("Circuit routing file: %s\n", FileNameOpts.RouteFile);

    ShowOperation(Operation);
	printf("Placer: %s\n", (PlacerOpts.doPlacement ? "ENABLED" : "DISABLED"));
	printf("Router: %s\n", (RouterOpts.doRouting ? "ENABLED" : "DISABLED"));
    
	if(PlacerOpts.doPlacement) {
		ShowPlacerOpts(Options, PlacerOpts, AnnealSched);
	}
    if(RouterOpts.doRouting)
	{
	    ShowRouterOpts(RouterOpts);
	}

    if(DETAILED == RouterOpts.route_type)
		ShowRoutingArch(RoutingArch);

    printf("\n");
    printf("Netlist num_nets:  %d\n", num_nets);
    printf("Netlist num_blocks:  %d\n", num_blocks);

	for(i = 0; i < num_types; i++)
	{
		num_blocks_type[i] = 0;
	}
    /* Count I/O input and output pads */
    num_p_inputs = 0;
    num_p_outputs = 0;

	for(i = 0; i < num_blocks; i++)
	{
		num_blocks_type[block[i].type->index]++;
		if(block[i].type == IO_TYPE)
		{
		    for(j = 0; j < IO_TYPE->num_pins; j++)
			{
			    if(block[i].nets[j] != OPEN)
				{
				    if(IO_TYPE->
				       class_inf[IO_TYPE->pin_class[j]].
				       type == DRIVER)
					{
					    num_p_inputs++;
					}
				    else
					{
					    assert(IO_TYPE->
						   class_inf[IO_TYPE->
							     pin_class[j]].
						   type == RECEIVER);
					    num_p_outputs++;
					}
				}
			}
		}
	}

	for(i = 0; i < num_types; i++)
	{
		if(IO_TYPE != &type_descriptors[i]) {
			printf("Netlist %s blocks:  %d\n", type_descriptors[i].name, num_blocks_type[i]);
		}
	}

	/* Print out each block separately instead */
    printf("Netlist inputs pins:  %d\n", num_p_inputs);
    printf("Netlist output pins:  %d\n", num_p_outputs);
    printf("\n");
	free(num_blocks_type);
}


static void
ShowRoutingArch(INP struct s_det_routing_arch RoutingArch)
{

    printf("RoutingArch.directionality:  ");
    switch (RoutingArch.directionality)
	{
	case BI_DIRECTIONAL:
	    printf("BI_DIRECTIONAL\n");
	    break;
	case UNI_DIRECTIONAL:
	    printf("UNI_DIRECTIONAL\n");
	    break;
	default:
	    printf("<Unknown>\n");
	    exit(1);
	}

    printf("RoutingArch.switch_block_type:  ");
    switch (RoutingArch.switch_block_type)
	{
	case SUBSET:
	    printf("SUBSET\n");
	    break;
	case WILTON:
	    printf("WILTON\n");
	    break;
	case UNIVERSAL:
	    printf("UNIVERSAL\n");
	    break;
	case FULL:
	    printf("FULL\n");
	    break;
	default:
	    printf("<Unknown>\n");
	    exit(1);
	}

    printf("RoutingArch.Fs:  %d\n", RoutingArch.Fs);

    printf("\n");
}


static void
ShowAnnealSched(INP struct s_annealing_sched AnnealSched)
{

    printf("AnnealSched.type:  ");
    switch (AnnealSched.type)
	{
	case AUTO_SCHED:
	    printf("AUTO_SCHED\n");
	    break;
	case USER_SCHED:
	    printf("USER_SCHED\n");
	    break;
	default:
	    printf("<Unknown>\n");
	    exit(1);
	}

    printf("AnnealSched.inner_num:  %f\n", AnnealSched.inner_num);

    if(USER_SCHED == AnnealSched.type)
	{
	    printf("AnnealSched.init_t:  %f\n", AnnealSched.init_t);
	    printf("AnnealSched.alpha_t:  %f\n", AnnealSched.alpha_t);
	    printf("AnnealSched.exit_t:  %f\n", AnnealSched.exit_t);
	}
}


static void
ShowRouterOpts(INP struct s_router_opts RouterOpts)
{

    printf("RouterOpts.route_type:  ");
    switch (RouterOpts.route_type)
	{
	case GLOBAL:
	    printf("GLOBAL\n");
	    break;
	case DETAILED:
	    printf("DETAILED\n");
	    break;
	default:
	    printf("<Unknown>\n");
	    exit(1);
	}

    if(DETAILED == RouterOpts.route_type)
	{
	    printf("RouterOpts.router_algorithm:  ");
	    switch (RouterOpts.router_algorithm)
		{
		case BREADTH_FIRST:
		    printf("BREADTH_FIRST\n");
		    break;
		case TIMING_DRIVEN:
		    printf("TIMING_DRIVEN\n");
		    break;
		case DIRECTED_SEARCH:
		    printf("DIRECTED_SEARCH\n");
		    break;
		default:
		    printf("<Unknown>\n");
		    exit(1);
		}

	    printf("RouterOpts.base_cost_type:  ");
	    switch (RouterOpts.base_cost_type)
		{
		case INTRINSIC_DELAY:
		    printf("INTRINSIC_DELAY\n");
		    break;
		case DELAY_NORMALIZED:
		    printf("DELAY_NORMALIZED\n");
		    break;
		case DEMAND_ONLY:
		    printf("DEMAND_ONLY\n");
		    break;
		default:
		    printf("<Unknown>\n");
		    exit(1);
		}

	    printf("RouterOpts.fixed_channel_width:  ");
	    if(NO_FIXED_CHANNEL_WIDTH == RouterOpts.fixed_channel_width)
		{
		    printf("NO_FIXED_CHANNEL_WIDTH\n");
		}
	    else
		{
		    printf("%d\n", RouterOpts.fixed_channel_width);
		}

	    printf("RouterOpts.acc_fac:  %f\n", RouterOpts.acc_fac);
	    printf("RouterOpts.bb_factor:  %d\n", RouterOpts.bb_factor);
	    printf("RouterOpts.bend_cost:  %f\n", RouterOpts.bend_cost);
	    printf("RouterOpts.first_iter_pres_fac:  %f\n",
		   RouterOpts.first_iter_pres_fac);
	    printf("RouterOpts.initial_pres_fac:  %f\n",
		   RouterOpts.initial_pres_fac);
	    printf("RouterOpts.pres_fac_mult:  %f\n",
		   RouterOpts.pres_fac_mult);
	    printf("RouterOpts.max_router_iterations:  %d\n",
		   RouterOpts.max_router_iterations);

	    if(TIMING_DRIVEN == RouterOpts.router_algorithm)
		{
		    printf("RouterOpts.astar_fac:  %f\n",
			   RouterOpts.astar_fac);
		    printf("RouterOpts.criticality_exp:  %f\n",
			   RouterOpts.criticality_exp);
		    printf("RouterOpts.max_criticality:  %f\n",
			   RouterOpts.max_criticality);
		}
	}
    else
	{
	    assert(GLOBAL == RouterOpts.route_type);
	    
		printf("RouterOpts.router_algorithm:  ");
	    switch (RouterOpts.router_algorithm)
		{
		case BREADTH_FIRST:
		    printf("BREADTH_FIRST\n");
		    break;
		case TIMING_DRIVEN:
		    printf("TIMING_DRIVEN\n");
		    break;
		case DIRECTED_SEARCH:
		    printf("DIRECTED_SEARCH\n");
		    break;
		default:
		    printf("<Unknown>\n");
		    exit(1);
		}

	    printf("RouterOpts.base_cost_type:  ");
	    switch (RouterOpts.base_cost_type)
		{
		case INTRINSIC_DELAY:
		    printf("INTRINSIC_DELAY\n");
		    break;
		case DELAY_NORMALIZED:
		    printf("DELAY_NORMALIZED\n");
		    break;
		case DEMAND_ONLY:
		    printf("DEMAND_ONLY\n");
		    break;
		default:
		    printf("<Unknown>\n");
		    exit(1);
		}

	    printf("RouterOpts.fixed_channel_width:  ");
	    if(NO_FIXED_CHANNEL_WIDTH == RouterOpts.fixed_channel_width)
		{
		    printf("NO_FIXED_CHANNEL_WIDTH\n");
		}
	    else
		{
		    printf("%d\n", RouterOpts.fixed_channel_width);
		}

	    printf("RouterOpts.acc_fac:  %f\n", RouterOpts.acc_fac);
	    printf("RouterOpts.bb_factor:  %d\n", RouterOpts.bb_factor);
	    printf("RouterOpts.bend_cost:  %f\n", RouterOpts.bend_cost);
	    printf("RouterOpts.first_iter_pres_fac:  %f\n",
		   RouterOpts.first_iter_pres_fac);
	    printf("RouterOpts.initial_pres_fac:  %f\n",
		   RouterOpts.initial_pres_fac);
	    printf("RouterOpts.pres_fac_mult:  %f\n",
		   RouterOpts.pres_fac_mult);
	    printf("RouterOpts.max_router_iterations:  %d\n",
		RouterOpts.max_router_iterations);
		if(TIMING_DRIVEN == RouterOpts.router_algorithm)
		{
		    printf("RouterOpts.astar_fac:  %f\n",
			   RouterOpts.astar_fac);
		    printf("RouterOpts.criticality_exp:  %f\n",
			   RouterOpts.criticality_exp);
		    printf("RouterOpts.max_criticality:  %f\n",
			   RouterOpts.max_criticality);
		}
	}
    printf("\n");
}


static void
ShowOperation(INP enum e_operation Operation)
{
    printf("Operation:  ");
    switch (Operation)
	{
	case RUN_FLOW:
	    printf("RUN_FLOW\n");
	    break;
	case TIMING_ANALYSIS_ONLY:
	    printf("TIMING_ANALYSIS_ONLY\n");
	    break;
	default:
	    printf("<Unknown>\n");
	    exit(1);
	}
    printf("\n");
}


static void
ShowPlacerOpts(INP t_options Options,
	       INP struct s_placer_opts PlacerOpts,
	       INP struct s_annealing_sched AnnealSched)
{

    printf("PlacerOpts.place_freq:  ");
    switch (PlacerOpts.place_freq)
	{
	case PLACE_ONCE:
	    printf("PLACE_ONCE\n");
	    break;
	case PLACE_ALWAYS:
	    printf("PLACE_ALWAYS\n");
	    break;
	case PLACE_NEVER:
	    printf("PLACE_NEVER\n");
	    break;
	default:
	    printf("<Unknown>\n");
	    exit(1);
	}
    if((PLACE_ONCE == PlacerOpts.place_freq) ||
       (PLACE_ALWAYS == PlacerOpts.place_freq))
	{

	    printf("PlacerOpts.place_algorithm:  ");
	    switch (PlacerOpts.place_algorithm)
		{
		case BOUNDING_BOX_PLACE:
		    printf("BOUNDING_BOX_PLACE\n");
		    break;
		case NET_TIMING_DRIVEN_PLACE:
		    printf("NET_TIMING_DRIVEN_PLACE\n");
		    break;
		case PATH_TIMING_DRIVEN_PLACE:
		    printf("PATH_TIMING_DRIVEN_PLACE\n");
		    break;
		default:
		    printf("<Unknown>\n");
		    exit(1);
		}

	    printf("PlacerOpts.place_cost_type:  ");
	    switch (PlacerOpts.place_cost_type)
		{
		case LINEAR_CONG:
		    printf("LINEAR_CONG\n");
		    break;
		case NONLINEAR_CONG:
		    printf("NONLINEAR_CONG\n");
		    break;
		default:
		    printf("<Unknown>\n");
		    exit(1);
		}

	    printf("PlacerOpts.pad_loc_type:  ");
	    switch (PlacerOpts.pad_loc_type)
		{
		case FREE:
		    printf("FREE\n");
		    break;
		case RANDOM:
		    printf("RANDOM\n");
		    break;
		case USER:
		    printf("USER '%s'\n", PlacerOpts.pad_loc_file);
		    break;
		default:
		    printf("<Unknown>\n");
		    exit(1);
		}

	    printf("PlacerOpts.place_cost_exp:  %f\n",
		   PlacerOpts.place_cost_exp);

	    if((LINEAR_CONG == PlacerOpts.place_cost_type) ||
	       (Options.Count[OT_PLACE_CHAN_WIDTH]))
		{
		    printf("PlacerOpts.place_chan_width:  %d\n",
			   PlacerOpts.place_chan_width);
		}

	    if(NONLINEAR_CONG == PlacerOpts.place_cost_type)
		{
		    printf("PlacerOpts.num_regions:  %d\n",
			   PlacerOpts.num_regions);
		}

	    if((NET_TIMING_DRIVEN_PLACE == PlacerOpts.place_algorithm) ||
	       (PATH_TIMING_DRIVEN_PLACE == PlacerOpts.place_algorithm))
		{
		    printf("PlacerOpts.inner_loop_recompute_divider:  %d\n",
			   PlacerOpts.inner_loop_recompute_divider);
		    printf("PlacerOpts.recompute_crit_iter:  %d\n",
			   PlacerOpts.recompute_crit_iter);
		    printf("PlacerOpts.timing_tradeoff:  %f\n",
			   PlacerOpts.timing_tradeoff);
		    printf("PlacerOpts.td_place_exp_first:  %f\n",
			   PlacerOpts.td_place_exp_first);
		    printf("PlacerOpts.td_place_exp_last:  %f\n",
			   PlacerOpts.td_place_exp_last);
		}

	    printf("PlaceOpts.seed:  %d\n", PlacerOpts.seed);

	    ShowAnnealSched(AnnealSched);
	}
    printf("\n");

}