/* st02.c CJP Version 1.1 08/10/07 */

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

#define MAXGENS 10000

void seteql(int a, int b);
int canon(int z);

int can[MAXGENS];
int ren[MAXGENS];

int main(int argc, char **argv)
{
    int i,j,k;
    int restart, good, changed;
    FILE *f1,*f2,*f3;
    int *gp,*inv,*rel,*b,*nb6,*ob6;
    int b6len,b6rels,rellen;
    int *b6pt,*nb6pt;
    int *b6read,*b6write;
    int *b4read,*b4write;
    int *b5read,*b5write;
    int newgens;
    int b4len, b5len;
    
    good=1;
    gp = (int*) malloc(sizeof(int)*GRPSIZ);
    if(gp==NULL) good=0;
    b = (int*) malloc(sizeof(int)*GRPSIZ);
    if(b==NULL) good=0;
    inv = (int*) malloc(sizeof(int)*GRPSIZ);
    if(inv==NULL) good=0;
    nb6 = (int*) malloc(sizeof(int)*GRPSIZ);
    if(nb6==NULL) good=0;
    ob6 = (int*) malloc(sizeof(int)*GRPSIZ);
    if(ob6==NULL) good=0;
    rel = (int*) malloc(sizeof(int)*GRPSIZ);
    if(rel==NULL) good=0;
    
    if(good==0)
    {
        printf("Error allocating memory in st02\n");
        return 0;
    }
    
    if(argc!=4)
    {
        printf("Usage: st02 <input> <output> <output>\n");
        return 0;
    }

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

    f3 = (FILE*) fopen(argv[3],"w");
    if(f3==NULL)
    {
        printf("Error opening file %s",argv[3]);
        return 0;
    }
    while(1)
    {
        changed=0;
        // Read in group (Breaking if fail)
        i = ReadGroup(gp,f1);
        if(i==-1) break;
       
        restart=2;       
        while(restart)
        {
            if(restart==1) changed=1;
            restart=0;
      
            ExtractBlimp(gp,3,inv);
            k=inv[1];
            for(i=0;i<k;i++)
            {
                inv[i] = inv[i+2]; 
            }

            for(i=1;i<=inv[0];i++)
                can[i]=i;
            
            ExtractBlimp(gp,6,ob6);
            b6len = 1;
            b6rels = 0;
            b6pt = &(ob6[3]);
            nb6pt = &(nb6[3]);
            
            // Learn Things (Pass A) (Something learnt, restart=1)
            for(i=0;i<ob6[2];i++)
            {
                rellen=0;            
                while(*b6pt!=0)
                {
                    rel[rellen] = *(b6pt++);
                    rellen++;
                }
                rel[rellen]=0;
                b6pt++;
                j = rellen;
                rellen = cancelrel(rel,inv);
                if(rellen!=j) changed=1;

                if(rellen>2)
                {
                    b6rels++;
                    b6len = b6len + rellen + 1;
                    for(j=0;j<rellen;j++)
                    {
                        *(nb6pt++) = rel[j];
                    }
                    *(nb6pt++) = 0;
                }
                else if(rellen==0)
                {
                    changed=1;
                }
                else if(rellen==1)
                {
                    restart=1;
                    changed=1;
                    can[canon(rel[0])] = 0;
                    can[canon(inv[rel[0]])] =0;
                }
                else if(rellen==2)
                {
                    restart=1;
                    changed=1;
                    seteql(rel[0],inv[rel[1]]);
                    seteql(inv[rel[0]],rel[1]);
                }
            }
            // APPLY THEM (PASS B)
            // Construct ren and newgens
            newgens=0;         
            for(i=1;i<=inv[0];i++)
            {
                if(canon(i)==0)
                    ren[i]=0;
                else
                {
                    if(canon(i)==i)
                    {
                        newgens++;
                        ren[i] = newgens;
                    }
                    else // canon(i) != i
                    {
                        ren[i] = ren[canon(i)];
                    }
                     
                }

            }

            // Apply ren/newgens to group
            if(restart==1)
            {
                // Blimp 3
                DeleteBlimp(gp,3);
                b[0]=3;
                b[1]=newgens+1;
                b[2]=newgens;
                for(i=1;i<=newgens;i++)
                {
                    j=1;
                    while(ren[j]!=i) j++;
                    b[i+2] = ren[inv[j]]; 
                }
                InsertBlimp(gp,b);
                // Blimp 4
                ExtractBlimp(gp,4,b);
                b4len=0; 
                b4read = &b[2];
                b4write = &b[2];
                for(i=1;i<=inv[0];i++)
                {                 
                    if(canon(i)==i)
                    {
                        while(*(b4read)!=0)
                        {
                            *(b4write++) = *(b4read++);
                            b4len++;
                        }
                        *(b4write++)=0;
                        b4read++;
                        b4len++;
                    }
                    else
                    {
                        while(*(b4read)!=0)
                        {
                            b4read++;
                        }
                        b4read++;
                    }
                }
                b[1] = b4len;
                DeleteBlimp(gp,4);
                InsertBlimp(gp,b);
                // Blimp 5
                ExtractBlimp(gp,2,b);
                j=b[2];

                ExtractBlimp(gp,5,b);
                b5read=&b[2];
                b5write=&b[2];
                b5len=0;
                for(i=1;i<=j;i++)
                {
                    while(*(b5read)!=0)
                    {
                        if(ren[*(b5read)]!=0)
                        {
                            b5len++;
                            *(b5write++) = ren[*(b5read++)];
                        }
                        else b5read++;

                    }
                    *(b5write++) = 0;
                    b5read++;
                    b5len++;
                }
                b[1] = b5len;
                DeleteBlimp(gp,5);
                InsertBlimp(gp,b);
                
                // Blimp 6
                DeleteBlimp(gp,6);
                nb6[0] = 6;
                b6read = &nb6[3];
                b6write = &nb6[3];
                for(i=0;i<b6rels;i++)
                {
                    b6pt=b6write;
                    while(*(b6read)!=0)
                    {
                        if(ren[*(b6read)]==0)
                        {
                            b6read++;
                            b6len--;
                        }
                        else
                        {
                            *(b6write++) = ren[*(b6read++)];
                        }
                    }
                    b6read++;
                    if(b6pt==b6write)
                    {
                        b6rels--;
                        b6len--;
                    }
                    else *(b6write++) = 0;
                }
                nb6[1] = b6len;
                nb6[2] = b6rels;              
                InsertBlimp(gp,nb6);
            
            }            
        }
        // Write out group to file
        if(changed==1) WriteGroup(gp,f2);
        if(changed==0) WriteGroup(gp,f3);
    }
    WriteEOF(f2);
    WriteEOF(f3);
    fclose(f1);
    fclose(f2);
    fclose(f3);
}

void seteql(int a, int b)
{
   int x,y;
   x=canon(a);
   y=canon(b);
   if(x==y) return;
   if(x<y)  can[y]=x;
   else can[x]=y;
}

int canon(int z)
{
   int x;
   x=can[z];
   while(x!=can[x])
       x=can[x];
   can[z]=x;
   return x;
}

int cancelrel(int *rel, int *inv) // inv is an array ST inv[1] is the inverse of 1, returns length
{
   
    int *ptread,*ptwrite;
    int len;
    int i,j;
    int restart;
  
    len = 0;
    ptread = rel;
    ptwrite = rel;
   
    while(rel[len]) len++;
    restart=1;
    while(restart)
    {
        restart=0;
        if(len<2) return len;
        while(rel[0]==inv[rel[len-1]])
        {
            for(i=0;i<len;i++)
            {
                rel[i]=rel[i+1];
            }
            len--;
            
            len--;
            rel[len]=0;
            restart=1;
        }
        if(restart==1) continue;
        i=0;
        if(len<2) return len;
        while(rel[i+1])
        {
            if(rel[i]==inv[rel[i+1]])
            {
                while(1)
                {
                    rel[i] = rel[i+2];
                    if(rel[i+2]==0) break;
                    i++;
                }
                restart=1;
                len--; len--;
                break;
            }
            i++;
        }
    }
    return len;
}

/* end of st02.c */