/**************************************************************
          *                                                            *
          *                                                            *
          *     find_circuits.cpp:  computes the Seifert circuits      *
          *                                                            *
          *                                                            *
          **************************************************************/


#include "link_diagram.h"



void Link::find_circuits()
{


    int i, j, t, creg, cindex=-1, num_quadrants_assigned;

    /*
     *  Create the Seifert circuits:  first find a circuit enclosing a single region,
     *  and declare it outermost, i.e. place point at infinity in this region
     */
    
    
    for ( i=1; i<=crossing_number; ++i )
    {
        Crossing *c = crossingList[i];
 
        c->nw->circuit_index = -1;
        c->sw->circuit_index = -1;
        c->se->circuit_index = -1;
        c->ne->circuit_index = -1;
    }
       
    
    for ( creg=1; creg<=crossing_number+2; ++creg )
    {
        Quadrant *q0 = baseQuadrantList[creg];
        
        t = 0;
        
        bool found = true;
        
        for ( Quadrant *q=q0; q!=q0 || t==0; q=q->next )
        {
            t = 1;
            
            if ( q -> arrow_type == source_sink )
            {
                found = false;
                break;
            }
        }
        
        if ( found )
        {
            ++cindex;
            
            Seifert_circuit *s = new Seifert_circuit;
            
            t = 0;
            
            s->sense = ( q0->detailed_arrow_type == turn_left ) ? clockwise : counterclockwise;
            
            for ( Quadrant *q=q0; q!=q0 || t==0; q=q->next )
            {
                t=1;
                
                q->circuit_index = cindex;
            
                s->quadrant_list.push_back( q );
            }

            s->length = num_sides[creg];
            
            s->index = cindex;
             
            num_quadrants_assigned = num_sides[creg];
            
            seifert_circuit_list.reserve(100);
            seifert_circuit_list.push_back( s );
            
            break;
        }
    }
   
    /*
     *  Find all the other circuits; for each contiguous pair of circuits,
     *  determine whether each is inside or outside the other
     */
            
    while ( num_quadrants_assigned < 2*crossing_number )
    {
        Quadrant *q0, *q;
        int i, ccirc, num_found, cc;
        
        num_found = cindex+1;
        
        for ( ccirc=0; ccirc<num_found; ++ccirc )
        {
            Seifert_circuit *s0 = seifert_circuit_list[ccirc];
            
            for ( j=0; j<seifert_circuit_list[ccirc]->length; ++j )
            {
               q = seifert_circuit_list[ccirc]->quadrant_list[j];

                if ( q->clockwise->clockwise->circuit_index != -1 ) continue;

                q0 = q->clockwise->clockwise;
 
                /*
                 *  q0  is a quadrant of a new circuit
                 */
  
                Seifert_circuit *s = new Seifert_circuit;
 
                s->previous_circuit = s0;
                s->previous_quadrant = q;
                q->tree = q0->tree = true;
                
                s->index = ++cindex;
                
                tree_contig[s0->index][s->index] = q;
                
                //  if sense is clockwise (counterclockwise), inside is on the right (left)
 
                if ( s0->sense == clockwise && q0->detailed_arrow_type == turn_right )
                {
                    s->sense = clockwise;
                    seifert_contig[s0->index][s->index] = up;
                    seifert_contig[s->index][s0->index] = down;
                }
 
                if ( s0->sense == clockwise && q0->detailed_arrow_type == turn_left )
                {

                    s->sense = counterclockwise;
                    seifert_contig[s0->index][s->index] = same_level;
                    seifert_contig[s->index][s0->index] = same_level;
                }
 
                if ( s0->sense == counterclockwise && q0->detailed_arrow_type == turn_right )
                {
                    s->sense = clockwise;
                    seifert_contig[s0->index][s->index] = same_level;
                    seifert_contig[s->index][s0->index] = same_level;
                }
 
                if ( s0->sense == counterclockwise && q0->detailed_arrow_type == turn_left )
                {
                    s->sense = counterclockwise;
                    seifert_contig[s0->index][s->index] = up;
                    seifert_contig[s->index][s0->index] = down;
                }
 
                t = 0;
 
                for ( Quadrant *q=q0; q!=q0 || t==0; q=q->seifert_next )
                {
                    t=1;
 
                    ++num_quadrants_assigned;
 
                    q->circuit_index = cindex;
 
                    s->quadrant_list.push_back( q );
                }
 
                s->length = s->quadrant_list.size();
 
                seifert_circuit_list.push_back( s );

            
            }
        }
    }
   
    num_seifert_circuits = cindex + 1;
    num_seifert_cycles = crossing_number - num_seifert_circuits + 1;

/*    
    printf( "number of circuits:%3d\n", num_seifert_circuits );
    printf( "\n" );
    
    for ( i=0; i<num_seifert_circuits; ++i )
    {
        Seifert_circuit *s = seifert_circuit_list[i];
        for ( j=0; j<s->length; ++j ) printf( "%3d", s->quadrant_list[j]->crossing->index );
        printf( "\n" );
    }
    printf( "\n" );
*/













}