/********************************
                   *                              *
                   *                              *
                   *       link_diagram.h         *
                   *                              *
                   *                              *
                   ********************************/



#include <vector>


struct Pass;
struct Crossing;
struct Edge;
struct Region;
struct Crossing_ray;
struct Quadrant;
struct Edge_side;
struct Flyping_circuit;
struct Slot_boundary;
struct Basic_pass;
struct Seifert_circuit;
struct Seifert_cycle;
struct QCQ_triple;

enum Ray  { north, west, south, east };
enum Mode  { forwards, backwards };
enum Color  { white, black };
enum Arrow_type  { source_sink=-1, flow_through=1 };
enum Detailed_arrow_type  { source, sink, turn_left, turn_right };
enum Join_type  { nw_to_ne, nw_to_se };
enum Direction  { in, out };
enum Level  { over, under };
enum Step  { up=1, same_level=0, down=-1 };
enum Sense  { clockwise=-1, counterclockwise=1 };


class Link
{

public:
    Link( std::vector<int> dt0 );
    ~Link();
    bool make_geometry();
    
    void make_seifert_matrix();
    void write_script();
            
    int crossing_number;
    int num_seifert_cycles;
    std::vector<std::vector<int> > seifert_matrix;
    

private:
    
    int link_number;
    int num_components;
    int num_seifert_circuits;
    
    
    std::vector<int> component_length;
    std::vector<int> comp_start, comp_end;
    std::vector<int> component;
    std::vector<int> dt;
    std::vector<int> dowker;
    std::vector<int> crossing_sign;           // left-right sign
    std::vector<int> alt_sign;                // over-under sign
    std::vector<int> next_index, prev_index, new_next_index, new_prev_index;
    std::vector<int> num_sides;               // num_sides[i] = number of sides of region i
    
    std::vector<Crossing *> crossingList;     // crossings of diagram
    std::vector<Edge *> edgeList;             // edges of diagram
    std::vector<Color> region_color;          // white or black
    std::vector<Quadrant *> baseQuadrantList; // each region has a "base" quadrant
    void setup_local_indices();

    std::vector<Basic_pass *> basicPassList;
    std::vector<Pass *> passList;
    
    std::vector<std::vector<int> > contig;
    std::vector<std::vector<Step> > seifert_contig;
    std::vector<std::vector<Quadrant *> > tree_contig;
    
    std::vector<Seifert_circuit *> seifert_circuit_list;
    std::vector<std::vector<QCQ_triple *> > seifert_cycle_list;
    
    bool compute_crossing_signs();                          // implement DT algorithm
    void clean_up_diagram();
    void initialize_vectors();
    void find_circuits();
    void tree();
    void find_cycles();
    void compute_linking();
    int cyclic_order( Quadrant *q1, Quadrant *q2, Quadrant *q3 );
    int interlace_test(  Quadrant *q1, Quadrant *q2, Quadrant *q3, Quadrant *q4 );
    
    Arrow_type i_to_a( int n );
};




struct Pass
{
    int index, new_index, crossing_sign, orientation, component, alt_sign;
    int circuit_index, tangle_index;
    Crossing *crossing;
    Pass *next;
    Pass *prev;
    Pass *partner;
    Level level;
};

struct Basic_pass
{
    int index, old_index, new_index, orientation, component, final_component, location, alt_sign;
    int crossing_sign;
    Edge *head, *tail;
    bool del_mark;
    Basic_pass *next, *prev, *partner;
    Basic_pass *new_next, *new_prev;
    Level level;
};


struct Crossing
{
    ~Crossing();
    int index;
    int sign, alt_sign, orientation;
    Crossing_ray *north, *west, *south, *east;
    Quadrant *ne, *nw, *sw, *se;
    Crossing_ray *n_neighbor, *w_neighbor, *s_neighbor, *e_neighbor;
    Pass *odd, *even, *over, *under;
};


struct Crossing_ray
{
    Crossing *crossing;
    
    Edge *edge;
    Mode mode;
    Ray compass_dir;
    Pass *pass;
    Crossing_ray *next, *prev; //counterclockwise, clockwise neighbors
    Quadrant *left_quadrant, *right_quadrant;
};


struct Quadrant
{
    Crossing *crossing;
    int region_index, region_num_sides, local_index;
    int twist;
    Quadrant *clockwise, *counterclockwise;
    Quadrant *next, *prev;
    Quadrant *seifert_next, *seifert_prev;
    Crossing_ray *left_ray, *right_ray;
    Color color;
    int circuit_index;
    Arrow_type arrow_type;
    Detailed_arrow_type detailed_arrow_type;
    bool tree;
};


struct Edge
{
    int index, left_region_index, right_region_index;
    int edge_sense;
    Edge_side *black_side, *white_side;
    Crossing_ray *rear, *front;
    Color left_color, right_color;
};


struct Edge_side
{
    int region_index, edge_index, local_index, edge_sense;
    Color color;
    Edge *edge;
};


struct Seifert_circuit
{
    int length;
    int index;
    Sense sense;
    std::vector<Quadrant *> quadrant_list;
    bool interlaced( int p, int q, int r, int s );
    Seifert_circuit *previous_circuit;
    Quadrant *previous_quadrant;
    std::vector<QCQ_triple *> path_from_root;
};


struct QCQ_triple
{
    Quadrant *forward_quadrant, *backward_quadrant;    // these quadrants are gateways from the
    Seifert_circuit *circuit;                          // current circuit to neighbouring ones
    QCQ_triple *next, *prev;                           // in the list
};