package Current.popups.Deg100;
import Current.*;
import Current.basic.*;
import Current.popups.Unfold.*;
import java.applet.Applet;
import java.awt.event.*;
import java.awt.*;

/**This class contains the routines in the Spine class which are
   relevant for the 100 Degree theorem.*/

public class Deg100Spine {

    /**This class contains methods which extract the defining
       functions from the combinatorial information calculated
       when we perform the combinatorial version of the unfolding.*/

    public Deg100Spine() {}

    /**Here is a palindrome test.  1 means palindrome*/

    public static int palindromeTest(CombinatorialTriangle[] T) {
	int N=T[0].c[0]+1;
	for(int i=1;i<N;++i) {
	    for(int j=0;j<=2;++j) {
	    if(T[i].b[j]+T[N-i].b[j]!=0) return(0);
	    }
	}
	return(1);
    }



    /**these are little routines which convert between our
       various ways of storing information*/

    public static int getDigit(String W,int q) {
	String S=new String();
	int m=0;
	int n=W.length();
	int qq=q;
	if(q<0) qq=q+n;
	if(q>=n) qq=q-n;
	S=W.substring(qq,qq+1);  
        if(S.compareTo("1")==0) m=0;
	if(S.compareTo("2")==0) m=1;
	if(S.compareTo("3")==0) m=2;
	return(m);
    }


    public static int lastDigit(String W) {
	return(getDigit(W,W.length()-1));
    }



    public static int[] getTriple(String W,int q) {
	int[] m=new int[3];
	int n=W.length();
	for(int i=-1;i<=1;++i) {
	    m[i+1]=getDigit(W,q+i);
	}
	return(m);
    }


    /**here j is the vertex type. 
       w[0] tells if the vertex is a top or bottom vertex.
       w[1] names the vertex
    */

    public static int[] typeToCoords(CombinatorialTriangle T,int j) {
	int[] w=new int[2];
	int up=1;
	if((T.c[0]==0)&&(j==1)) up=-1;
	if((T.c[0]==1)&&(j==2)) up=-1;
	if((T.c[0]==2)&&(j==0)) up=-1;
	up=up*T.parity;
	if(up==1) w[0]=1;
	if(up==-1) w[0]=2;
	if(up==-1) w[1]=T.c[2];
	if(up==+1) w[1]=T.c[1];
	return(w);
    }


    public static int findType(CombinatorialTriangle T,int up,int m) {
	int test=-T.parity;
	if(up==2) test=-test;
	int j=T.c[0]+test;
	if(j>=3) j=j-3;
	if(j<0) j=j+3;
	return(j);
    }

    public static int spineNumber(VertexPair V,CombinatorialTriangle[] T) {
	int n1=coordsToType(T[V.e1],V.o1);
        int n2=coordsToType(T[V.e2],V.o2);
	if(n1!=n2) return(3-n1-n2);
	if(n1==2) return(1);
	return(2);
    }

    public static int coordsToType(CombinatorialTriangle T,int m0) {
	return((3+T.c[0]+T.parity*(2*m0-3))%3);
    }





    /**a return of 
    -1 means that the pair is misordered
     1 means that the pair is correctly ordered
     2 or 3 means that the vertices are the
     two endpoints of an interior edge
    */


    public static int pairOrdering(VertexPair V,CombinatorialTriangle[] CT) {
      int n1,n2,n3,n4;
      n1=CT[V.e1].c[V.o1];
      n2=CT[V.e2].c[V.o2];
      n3=CT[V.e1].c[3-V.o1];
      n4=CT[V.e2].c[3-V.o2];

      if(V.o1==V.o2) {
        if(n1==n2) return(0);
        if(n1<n2) return(1);
        if(n1>n2) return(-1);
      }

      if((n1==n4)) return(2);
      if((n2==n3)) return(3);
      if(n3<n2) return(1);
      if(n1<n4) return(1);
      return(-1);
    }

    public static VertexPair swap(VertexPair V,int i) {
      VertexPair V2=new VertexPair(V.o1,V.e1,V.o2,V.e2);
      if(i==-1) {
        V2.o2=V.o1;
        V2.e2=V.e1;  
        V2.o1=V.o2;
        V2.e1=V.e2; 
      }
     return(V2);
    }








    /**now we have the routines which compute the spine*/

    /**first the "numerator" part*/

    public static int[] computeSpine(VertexPair V,CombinatorialTriangle[] CT) {
      int first,last,count;
      int[] n=new int[CT[0].c[0]+3];
      VertexPair V2=new VertexPair();
      int order=pairOrdering(V,CT);
      int spine=spineNumber(V,CT);


      //sign convention
      int convention=1;
      if((order==-1)&&(V.o1==1)&&(V.o2==2)) convention=-1;
      if((order== 2)&&(V.o1==1)&&(V.o2==2)) convention=-1;
      if((order== 1)&&(V.o1==2)&&(V.o2==1)) convention=-1;	
      if((order== 3)&&(V.o1==2)&&(V.o2==1)) convention=-1;

      if((V.o1==V.o2)&&(order==0)) {n[0]=0;n[1]=convention;n[2]=spine;return(n);}            //exceptional
      if((V.o1!=V.o2)&&(order==2)) {n[1]=V.e2;n[0]=1;n[2]=convention;n[3]=spine;return(n);}  //exceptional
      if((V.o1!=V.o2)&&(order==3)) {n[1]=V.e1;n[0]=1;n[2]=convention;n[3]=spine;return(n);}  //exceptional

      V2=swap(V,order);
      first=CT[V2.e1].e[0][V2.o1-1];
      last= CT[V2.e2].e[1][V2.o2-1];

      if(first>=last) {n[1]=first;n[0]=1;n[2]=convention;n[3]=spine;return(n);}              //exceptional
      count=2;   
      for(int i=first+1;i<last;++i) {        
        if(CT[i].a[spine]==1)  {
        n[count]=i; ++count; }
      }
      n[1]=first;
      n[count]=last;
      n[0]=count;
      n[count+1]=convention;
      n[count+2]=spine;
      return(n);
    }

    public static int getFirstTerm(VertexPair V,CombinatorialTriangle[ ] CT) {

      VertexPair V2=new VertexPair();
      int order=pairOrdering(V,CT);
      int spine=spineNumber(V,CT);

      if((V.o1==V.o2)&&(order==0)) return(0);
      if((V.o1!=V.o2)&&(order==2)) return(V.e2);
      if((V.o1!=V.o2)&&(order==3)) return(V.e1);

      V2=swap(V,order);
      return(CT[V2.e1].e[0][V2.o1-1]);
    }


    public static int getSign(VertexPair V,CombinatorialTriangle[] CT,int[][] d) {
	return(Function.getSign(getFirstTerm(V,CT),d));
    }







    /**the "denominator" part*/


    public static  int[] trim(int[] n) {
	int[] m=new int[n[0]];
	m[0]=n[0]-1;      
        for(int i=1;i<=m[0];++i) m[i]=n[i+1];
	return(m);
    }


    public static int[] fullSpine(VertexPair V,CombinatorialTriangle[] CT) {
      int spine=spineNumber(V,CT);
      return(fullSpine(spine,CT));
    }



    public static int[] fullSpine(int spine,CombinatorialTriangle[] CT) {
      int[] n=new int[CT[0].c[0]+1];
      int N=CT[0].c[0];
      n[1]=1;
      int count=2;   
      for(int i=2;i<N;++i) {        
         if(CT[i].a[spine]==1)  {
           n[count]=i; ++count; }
      }
      n[count]=N;
      n[0]=count;


  /**trimming the edges:  We trim off as much of the
     initial portion as possible and then make the length
     of the spine even.*/

    int[] w1=CT[n[1]].d[spine];
    int[] w2=CT[n[2]].d[spine];
    if((w1[0]==w2[0])&&(w1[1]==w2[1])) n=trim(n);     //kills repeaters

    w1=CT[n[1]].d[spine];
    w2=CT[n[2]].d[spine];
    if((w1[0]==0)&&(w1[1]==0)) n=trim(n);             //kills redundant first edge

    w1=CT[n[1]].d[spine];
    w2=CT[n[2]].d[spine];
    if((w1[0]==0)&&(w2[0]==0)) n=trim(n);             //kills extra type 1 tail
    if((w1[1]==0)&&(w2[1]==0)) n=trim(n);             //kills extra type 2 tail
    if((w1[0]==w1[1])&&(w2[0]==w2[1])) n=trim(n);     //kills extra type 3 tail

    if(n[0]%2==1) --n[0];                             //the spines always have even length

    return(n);
    }
    

}