package Current.search;

import java.lang.Thread;

import Current.basic.*;
import Current.search.basic.*;
import Current.*;

public class SubwordSearch extends Thread {
    /** interface with this to interact with the BasicSearch class */
    
    private Complex tri; // coordinates for triangle
    private int depth;
    private Searcher bs;
    private boolean interrupt;
    private String sw;
    
    private class SearchData {
        SlalomUnfolding.DataBackup db;
        int lexi, next;
        
        public SearchData(SlalomUnfolding SU, int NEXT) {
            db=SU.backup();
            next=NEXT;
        }
    }
    
    /** The BasicSearcher is the class that handles the responses */
    public SubwordSearch(Complex tri, int depth, String sw, Searcher BS){
        bs=BS;
        this.tri=new Complex(tri);
        this.depth=depth;
        this.sw=sw;
        start();
    }

    /** The BasicSearcher is the class that handles the responses */
    public SubwordSearch(double x, double y, int depth, String sw, Searcher BS){
        bs=BS;
        this.tri=new Complex(x,y);
        this.depth=depth;
        this.sw=sw;
        start();
    }
    
    public void interrupt() {
        interrupt=true;
    }
    
    /** Start the search! */
    public void run(){
        if ((sw==null)||(sw==null)) {
            System.out.println("Subword is null! Search failed.");
            return;
        } else {
            //System.out.println("searching with subword \""+sw+"\"");
        }
        interrupt=false;
        //int languish=0;
        // for storing the results:
        StringWordOrganizer results=new StringWordOrganizer();
        
        // backup the depth (it may change otherwise)
        int d=depth;
        
        /** Information used when searching */
        int w[]=new int[d];     // array of letters in the word
        if (sw.length()>d) {
            System.out.println("Subword longer than depth! Search failed.");
            return;
        }
        
        HexPosition hp=new HexPosition();           // current position in hex grid
        SlalomUnfolding su=new SlalomUnfolding(tri,sw.charAt(0)-'1');
        for (int i=0; i<sw.length();i++) {
            hp.shift(sw.charAt(i)-'1');
            w[i]=sw.charAt(i)-'1';
            if (i>0) {
                if (!su.addEdge(sw.charAt(i)-'1')) {
                    //System.out.println("Subword eliminated by weak test! Search failed.");
                    bs.doneBasicSearch(new Results(tri));
                    return;
                }
            }
        }
        
        int l=sw.length();                  // current word length
        
        
        
        SearchData sd[]=new SearchData[d+1];
        
        int next,next2,dist,dist2,dist3;
        
        while (l>1){
            if (interrupt) {
                System.out.println("search interupted");
                return;
            }
            //System.out.println("Statistics: length="+l+" size="+su.size());
            //            if (l==151)
            //                System.out.println("help");
            if ( ((dist=hp.dist())==0) &&
            (su.strongTest()) ) {
                StringBuffer temp=new StringBuffer(l);
                for (int i=0; i<l; i++){
                    temp.append((char)('1'+w[i]));
                }
                results.add(temp.toString());
            }
            next=(w[l-1]+1)%3;
            if (hp.even())
                if (hp.p[next]>=0)
                    dist2=dist+1;
                else
                    dist2=dist-1;
            else
                if (hp.p[next]<=0)
                    dist2=dist+1;
                else
                    dist2=dist-1;
            
            //            if ((next>=w[lexi])&&           // lexi-test
            //            (!(dist2+l<d))&&               // distance test
            //            (su.survivesAdd(next)) &&       // slalom test
            //            (reverseLexiTest(w,l,next))) {   //reverse lexi test
            //                languish++;
            //            }
            
            
            if ((dist2+l<d)&&               // distance test
            (su.survivesAdd(next))) {   //weak test
                next2=(w[l-1]+2)%3;
                if (hp.even())
                    if (hp.p[next]>=0)
                        dist3=dist+1;
                    else
                        dist3=dist-1;
                else
                    if (hp.p[next]<=0)
                        dist3=dist+1;
                    else
                        dist3=dist-1;
                
                //                if ((next2>=w[lexi])&&           // lexi-test
                //                (!(dist3+l<d))&&               // distance test
                //                (su.survivesAdd(next2)) &&       // slalom test
                //                (reverseLexiTest(w,l,next2))) {   //reverse lexi test
                //                    languish++;
                //                }
                
                
                if ( (dist3+l<d)&&               // distance test
                (su.survivesAdd(next2)) ) {       // slalom test
                    // we need to add both
                    // copy to backup
                    sd[l-1]=new SearchData(su,next2);
                    
                    // add next
                    if (!su.addEdge(next)) {
                        System.out.println("unexpected failure of slalom test");
                        return;
                    }
                    hp.shift(next);
                    w[l++]=next;
                } else {
                    // we only need to add next
                    if (!su.addEdge(next)) {
                        System.out.println("unexpected failure of slalom test");
                        return;
                    }
                    hp.shift(next);
                    w[l++]=next;
                }
            } else {
                next2=(w[l-1]+2)%3;
                if (hp.even())
                    if (hp.p[next]>=0)
                        dist3=dist+1;
                    else
                        dist3=dist-1;
                else
                    if (hp.p[next]<=0)
                        dist3=dist+1;
                    else
                        dist3=dist-1;
                
                //                if ((next2>=w[lexi])&&           // lexi-test
                //                (!(dist3+l<d))&&               // distance test
                //                (su.survivesAdd(next2)) &&       // slalom test
                //                (reverseLexiTest(w,l,next2))) {   //reverse lexi test
                //                    languish++;
                //                }
                
                if ( (dist3+l<d)&&               // distance test
                (su.survivesAdd(next2)) ) {       // slalom test
                    // we only need to add next2
                    if (!su.addEdge(next2)) {
                        System.out.println("unexpected failure of slalom test");
                        return;
                    }
                    hp.shift(next2);
                    w[l++]=next2;
                } else {
                    l=l-1;
                    hp.shift(w[l]);
                    while ((l>1)&&(sd[l-1]==null)){
                        l=l-1;
                        hp.shift(w[l]);
                    }
                    if (l>1) {
                        next=sd[l-1].next;
                        su.recover(sd[l-1].db);
                        sd[l-1]=null;
                        
                        if (!su.addEdge(next)) {
                            System.out.println("unexpected failure of slalom test");
                            return;
                        }
                        hp.shift(next);
                        w[l++]=next;
                    }
                }
            }
        }
        //System.out.println("Languishing words="+languish);
        bs.doneBasicSearch(new Results(results.toArray(),tri));
    }
}