/******************************************************
          *                                                    *
          *     link_diagram.cpp:  contains the contructor     *
          *     and destructor for the class Link              *
          *                                                    *
          ******************************************************/

 

#include "link_diagram.h"
#include <cstdlib>
#include <cstdio>

void setup_local_indices(Link *link);


Crossing :: ~Crossing()
{
    delete se;
    delete sw;
    delete nw;
    delete ne;
    delete east;
    delete south;
    delete west;
    delete north;
}

Link::~Link()
{

    clean_up_diagram();
    
    dt.clear();

    crossing_sign.clear();
    component_length.clear();
    
    dowker.clear();
    
    dt.clear();
    
    comp_start.clear();
    comp_end.clear();

}


Link::Link( std::vector<int> dt0 )
{

    int i, j, t;
            
    crossing_number = dt0[0];
    
    num_components = dt0[1];
    
    initialize_vectors();
    
    for ( i=2; i<2+num_components; ++i ) component_length[i-2] = dt0[i];
    
    for ( i=2+num_components; i<2+num_components+crossing_number; ++i )
        dt[i-1-num_components] = dt0[i];
    
    for ( i=1; i<=crossing_number; ++i )
    {
        alt_sign[2*i-1] = dt[i]/abs(dt[i]);
        dowker[2*i-1] = abs(dt[i]);
    }
    
    for ( i=1; i<=2*crossing_number-1; i+=2 )
    {
        alt_sign[dowker[i]] = -alt_sign[i];
        dowker[dowker[i]] = i;
    }

    comp_start[0] = 1;
    comp_end[0] = component_length[0];
    
    for ( i=1; i<num_components; ++i )
    {
        comp_start[i] = comp_start[i-1] + component_length[i-1];
        comp_end[i] = comp_end[i-1] + component_length[i];
    }
    
    for (i=0; i<num_components; ++i) for ( j=comp_start[i]; j<=comp_end[i]; ++j )
    {
        component[j] = i;
        next_index[j] = ( j < comp_end[i] ) ? j+1 : comp_start[i];
        prev_index[j] = ( j > comp_start[i] ) ? j-1 : comp_end[i];
    }
    
    
    compute_crossing_signs();
    
}


void Link::initialize_vectors()
{
    int i;
    
    for ( i=0; i<=crossing_number; ++i ) dt.push_back( 0 );

    for ( i=0; i<=2*crossing_number; ++i ) dowker.push_back( 0 );
    
    for ( i=0; i<=2*crossing_number; ++i ) alt_sign.push_back( 0 );
    
    for ( i=0; i<num_components; ++i ) component_length.push_back( 2*crossing_number );
                 
    component.reserve( 2*crossing_number+1 );
    next_index.reserve( 2*crossing_number+1 );
    prev_index.reserve( 2*crossing_number+1 );
    comp_start.reserve( num_components );
    comp_end.reserve( num_components);

    crossing_sign.reserve( 2*crossing_number + 1 );
    
    for ( i=0; i<=crossing_number+2; ++i )
    {
        std::vector<int> x( crossing_number + 3, 0 );
        contig.push_back( x );
    }
    
    for ( i=0; i<crossing_number; ++i )
    {
        std::vector<Step> x( crossing_number );
        seifert_contig.push_back( x );
    }
    
    for ( i=0; i<crossing_number; ++i )
    {
        std::vector<Quadrant *> x( crossing_number );
        tree_contig.push_back( x );
    }

    for ( i=0; i<crossing_number; ++i )
    {
        std::vector<int> x( crossing_number );
        seifert_matrix.push_back( x );
    }

}
    

void Link::clean_up_diagram() 
{
    int i, j;

    /*
     *  clear memory allocated in make_geometry()
     */    
    
    for (i=0; i<=crossing_number+2; ++i) 
    {
        contig[i].clear();
    }
        
    contig.clear();
    
    for (i=0; i<crossingList.size(); ++i) delete crossingList[i];
    
    crossingList.clear();

    for (i=0; i<edgeList.size(); ++i)
    {
        delete edgeList[i]->black_side;
        delete edgeList[i]->white_side;
        delete edgeList[i];
    }
    
    edgeList.clear();
    
    for (i=0; i<=2*crossing_number; ++i)
    {
        delete passList[i];
    }

    passList.clear();    

    baseQuadrantList.clear();
    region_color.clear();
    num_sides.clear();
    next_index.clear();
    prev_index.clear();
    
    /*
     *  clear memory allocated in seifert matrix functions
     */

    for ( i=0; i<num_seifert_circuits; ++i )
    {
        for ( j=0; j<seifert_circuit_list[i]->path_from_root.size(); ++j )
            delete seifert_circuit_list[i]->path_from_root[j];
        seifert_circuit_list[i]->path_from_root.clear();
        
        seifert_circuit_list[i]->quadrant_list.clear();
        
        delete seifert_circuit_list[i];
        seifert_contig[i].clear();
        tree_contig[i].clear();
    }
        
    seifert_contig.clear();
    seifert_circuit_list.clear();
    tree_contig.clear();
    
    for ( i=0; i<num_seifert_cycles; ++i )
    {
        for ( j=0; j<seifert_cycle_list[i].size(); ++j )
            delete seifert_cycle_list[i][j];
        seifert_cycle_list[i].clear();
        
        seifert_matrix[i].clear();
    }
    
    seifert_cycle_list.clear();
    seifert_matrix.clear();
    
 
}




void Link::setup_local_indices()
{
    int i, j;
    Quadrant *q;
    
    /*
     *  Each base quadrant is assigned local index 0, as is the
     *  clockwise edge_side of the base quadrant.  Then local indices
     *  increment in a counterclockwise direction around the region.
     */

    for (i=1; i<=crossing_number+2; ++i)
    {     
        q = baseQuadrantList[i];
        
        for (j=0; j<num_sides[i]; ++j)
        {
            q->local_index = j;
            q->clockwise->local_index = j;
            q = q->next;
        }
    }
}



Arrow_type Link::i_to_a( int n )
{
    if (n==0) return source_sink;
    if (n==1) return flow_through;
}