/* st07.c CJP Version 1.2 08/01/08 */
#define MAXGENS 10000

#include<stdlib.h>
#include<stdio.h>
#include"blimp.h"

int number(int a, int b, int c);

int main(int argc, char **argv)
{
    int tmpword1[5];
    int tmpword2[5];
    int i,j,k,n;
    int good;
    FILE *f1,*f2;
    int *gp,*b2,*origb2,*inv;
    int lg;
    int num;
    int *lrel;
    int *pt;
    good=1;
    gp = (int*) malloc(sizeof(int)*GRPSIZ);
    if(gp==NULL) good=0;
    b2 = (int*) malloc(sizeof(int)*GRPSIZ);
    if(b2==NULL) good=0;
    inv = (int*) malloc(sizeof(int)*GRPSIZ);
    if(inv==NULL) good=0;
    lrel = (int*) malloc(sizeof(int)*5);
    if(lrel==NULL) good=0;
    
    if(good==0)
    {
        printf("Error allocating memory in st07\n");
        return 0;
    }

    if(argc!=3)
    {
        printf("Usage: st07 <input> <output>\n");
        return 0;
    }

    f1 = (FILE*) fopen(argv[1],"r");
    if(f1==NULL)
    {
        printf("Error opening file %s\n",argv[2]);
        return 0;
    }
    
    f2 = (FILE*) fopen(argv[2],"w");
    if(f2==NULL)
    {
        printf("Error opening file %s\n",argv[3]);
        return 0;
    }

    while(1)
    {        
        i = ReadGroup(gp,f1);
        if(i==-1) break;

        n=ListBlimps(gp,b2);
	for(i=0;i<n;i++)
            if((b2[i]>2)&&(b2[i]!=999)) DeleteBlimp(gp,b2[i]);
        
        // Take External Presentation
        ExtractBlimp(gp,2,b2);
        // Build inverse table USING BLIMP 2
        inv[0] = b2[2];
        pt = &b2[3];
        for(i=0;i<b2[3];i++)
        {
            pt++;
            j=0;
            while(*pt!=0)
            {
                pt++;
                j++;
            }
            if(j==2)
            {
                inv[*(pt-1)] = *(pt-2);
                inv[*(pt-2)] = *(pt-1);
            }
        }
        // Locate largest generator for rel (g if involution, g-1 if not)
        lg = inv[0];
        if(inv[lg]!=lg) lg = lg-1;
        // Find Largest Relator in External
        lrel[0]=0;
        lrel[1]=0;
        lrel[2]=0;
        pt = &b2[4];
        
        for(i=0;i<b2[3];i++)
        {
            j=0;
            while(*pt!=0)
            {
                pt++;
                j++;
            }
         
            if(j==3)
            {              
                if(*(pt-1)<lg && *(pt-2)<lg && *(pt-3)<lg)
                {
                    k++;
                         
                    // Ignore this relator
                }
                else
                {
                    if(comparerels2(pt-3, lrel)>0)
                    {                      
                        lrel[0]= *(pt-3);
                        lrel[1]= *(pt-2);
                        lrel[2]= *(pt-1);                    
                    }
                }
            }
            pt++;
        }
        // Generate all relators involving that gen
  
        for(i=1;i<=inv[0];i++)
        {
             for(j=1;j<=inv[0];j++)
             {
                 if(i==inv[j]) continue;
                 for(k=1;k<=inv[0];k++)
                 {
                     if(j==inv[k]) continue;
                     if(k==inv[i]) continue;
                     // Check for earliest of Rotations
                     tmpword1[0]=i; tmpword1[1]=j; tmpword1[2]=k;
                 
                     tmpword2[0]=j; tmpword2[1]=k; tmpword2[2]=i;
                     if(comparerels2(tmpword1,tmpword2)>0) continue;
                  
                     tmpword2[0]=k; tmpword2[1]=i; tmpword2[2]=j;
                     if(comparerels2(tmpword1,tmpword2)>0) continue;
                 
                     tmpword2[0]=inv[i]; tmpword2[1]=inv[k]; tmpword2[2]=inv[j];
                     if(comparerels2(tmpword1,tmpword2)>0) continue;
                  
                     tmpword2[0]=inv[j]; tmpword2[1]=inv[i]; tmpword2[2]=inv[k];
                     if(comparerels2(tmpword1,tmpword2)>0) continue;
                   
                     tmpword2[0]=inv[k]; tmpword2[1]=inv[j]; tmpword2[2]=inv[i];
                     if(comparerels2(tmpword1,tmpword2)>0) continue;
                                       
                     // Check later than "last relator"
                     if((comparerels2(tmpword1,lrel) > 0) && !(i<lg && j<lg && k<lg) )                         
                     {
                         DeleteBlimp(gp,2);
                         b2[b2[1]+2]=i;
                         b2[b2[1]+3]=j;
                         b2[b2[1]+4]=k;
                         b2[b2[1]+5]=0;
                         b2[1]=b2[1]+4;
                         b2[3]=b2[3]+1;
                         InsertBlimp(gp,b2);
                         WriteGroup(gp,f2);
                         b2[1]=b2[1]-4;
                         b2[3]=b2[3]-1;
                     }
                 }
             }
        }
    }
    WriteEOF(f2);
    fclose(f1);
    fclose(f2); 
}

int comparerels2(const void *a, const void *b) // Return -ve if first is less
{
    int* zero = ((int*) a);
    int* one = ((int*) b);
    int z0[3],z1[3];
    int wz0,wz1;
    int i,j,k;
    
    for(i=0;i<3;i++)
    {
        if(zero[i]<=zero[(i+1)%3] && zero[i]<=zero[(i+2)%3]) {
            z0[0] = zero[i]; wz0=i; }
        if(one[i]<=one[(i+1)%3] && one[i]<=one[(i+2)%3]) {
            z1[0] = one[i]; wz1 = i; }
    }

    if(zero[(wz0+1)%3] <= zero[(wz0+2)%3])
    {
        z0[1] = zero[(wz0+1)%3];
        z0[2] = zero[(wz0+2)%3];
    }
    else
    {
        z0[1] = zero[(wz0+2)%3];
        z0[2] = zero[(wz0+1)%3];
    }
    if(one[(wz1+1)%3] <= one[(wz1+2)%3])
    {
        z1[1] = one[(wz1+1)%3];
        z1[2] = one[(wz1+2)%3];
    }
    else
    {
        z1[1] = one[(wz1+2)%3];
        z1[2] = one[(wz1+1)%3];
    }
    
    if(z0[2] < z1[2]) return -1;
    if(z0[2] > z1[2]) return 1;
    
    if(z0[1] < z1[1]) return -1;
    if(z0[1] > z1[1]) return 1;

    if(z0[0] < z1[0]) return -1;
    if(z0[0] > z1[0]) return 1;

    
    
    if(zero[0] < one[0]) return -1;
    if(zero[0] > one[0]) return 1;

    if(zero[1] < one[1]) return -1;
    if(zero[1] > one[1]) return 1;

    if(zero[2] < one[2]) return -1;
    if(zero[2] > one[2]) return 1;
    
    return 0;
}