import java.util.regex.Pattern;

/* 
 * Thread class used to populate the first input buffer in the
 * chain, i.e.  Router's input buffer.
 */
class ChickenInputThread extends Thread {
    FilterBuffer buffer;

    public ChickenInputThread(FilterBuffer buf) {
        buffer = buf;
    }

    public void run() {
        try {
            ChickenPart[] toWrite = ChickenData.data;
            for (int i = 0; i < toWrite.length; i++)
                buffer.write(toWrite[i].toString().toCharArray());
            buffer.close();
        } catch (BufTooSmallException e) {
            e.printStackTrace();
        }
    }
}

/* 
 * Thread class used to print the output buffers on the end of the
 * chain, for debugging use.
 */
class ChickenOutputThread extends Thread {
    static Object printLock = new Object();
    FilterBuffer buffer;
    String myId;

    public ChickenOutputThread(FilterBuffer buf, String id) {
        buffer = buf;
        myId = id;
    }

    public void run() {
        while (true) {
            char[] input = buffer.read();
            if (input.length == 0) break;
            synchronized (printLock) {
                System.out.print ("(" + myId + ") ");
                System.out.println(input);
            }
        }
    }
}


/*
 * Driver for Chicken Sorting application.
 */
public class Chicken {

    static public void main(String args[]) {

        // Create input and output buffers for Router filter
        FilterBuffer rtrInput = new FilterBufferImpl(100);
        FilterBuffer rtrOutput1 = new FilterBufferImpl(100);
        FilterBuffer rtrOutput2 = new FilterBufferImpl(100);
        // Create Compute "thread" for Router filter.
        Compute rtr = new Router();

        // Create Router filter. 
        Filter rtrFilter = new FilterImpl(rtr, rtrInput, rtrOutput1);
        // Add second output buffer to Router filter.
        rtrFilter.addOutputBuffer(rtrOutput2);
        // Give the Compute instance a reference to the Filter
        // instance.
        rtr.setFilter(rtrFilter);

        // Create input and output buffers for Station filters.
        FilterBuffer stn1Input = rtrOutput1;
        FilterBuffer stn1Output1 = new FilterBufferImpl(100);
        FilterBuffer stn1Output2 = new FilterBufferImpl(100);
        FilterBuffer stn1Output3 = new FilterBufferImpl(100);
        FilterBuffer stn1Output4 = new FilterBufferImpl(100);
        FilterBuffer stn2Input = rtrOutput2;
        FilterBuffer stn2Output1 = new FilterBufferImpl(100);
        FilterBuffer stn2Output2 = new FilterBufferImpl(100);
        FilterBuffer stn2Output3 = new FilterBufferImpl(100);
        FilterBuffer stn2Output4 = new FilterBufferImpl(100);
        // Create Compute "threads" for Station filters.
        Compute stn1 = new Station();
        Compute stn2 = new Station();

        // Create Station filters. 
        Filter stnFilter1 = new FilterImpl(stn1, stn1Input, stn1Output1);
        Filter stnFilter2 = new FilterImpl(stn2, stn2Input, stn2Output1);
        // Add other three output buffers to Station filters.
        stnFilter1.addOutputBuffer(stn1Output2);
        stnFilter1.addOutputBuffer(stn1Output3);
        stnFilter1.addOutputBuffer(stn1Output4);
        stnFilter2.addOutputBuffer(stn2Output2);
        stnFilter2.addOutputBuffer(stn2Output3);
        stnFilter2.addOutputBuffer(stn2Output4);
        // Give the Compute instance a reference to the Filter
        // instance.
        stn1.setFilter(stnFilter1);
        stn2.setFilter(stnFilter2);

        // Create input buffers for eight Bin filters. (Four per
        // station.)
        // Note that the Bin filters' input buffers are the same as
        // Stations' output buffers.
        FilterBuffer bin1Input = stn1Output1;
        FilterBuffer bin2Input = stn1Output2;
        FilterBuffer bin3Input = stn1Output3;
        FilterBuffer bin4Input = stn1Output4;
        FilterBuffer bin5Input = stn2Output1;
        FilterBuffer bin6Input = stn2Output2;
        FilterBuffer bin7Input = stn2Output3;
        FilterBuffer bin8Input = stn2Output4;
        // Create Compute "threads" for Bin filters
        Compute bin1 = new Bin("(Station 1) WingsOnly", 250, 300);
        Compute bin2 = new Bin("(Station 1) DrumsOnly", 250, 300);
        Compute bin3 = new Bin("(Station 1) Mixed1", 350, 400);
        Compute bin4 = new Bin("(Station 1) Mixed2", 350, 400);
        Compute bin5 = new Bin("(Station 2) WingsOnly", 250, 300);
        Compute bin6 = new Bin("(Station 2) DrumsOnly", 250, 300);
        Compute bin7 = new Bin("(Station 2) Mixed1", 350, 400);
        Compute bin8 = new Bin("(Station 2) Mixed2", 350, 400);

        // Create Bin filters.
        Filter binFilter1 = new FilterImpl(bin1, bin1Input, new FilterBufferImpl(0));
        Filter binFilter2 = new FilterImpl(bin2, bin2Input, new FilterBufferImpl(0));
        Filter binFilter3 = new FilterImpl(bin3, bin3Input, new FilterBufferImpl(0));
        Filter binFilter4 = new FilterImpl(bin4, bin4Input, new FilterBufferImpl(0));
        Filter binFilter5 = new FilterImpl(bin5, bin5Input, new FilterBufferImpl(0));
        Filter binFilter6 = new FilterImpl(bin6, bin6Input, new FilterBufferImpl(0));
        Filter binFilter7 = new FilterImpl(bin7, bin7Input, new FilterBufferImpl(0));
        Filter binFilter8 = new FilterImpl(bin8, bin8Input, new FilterBufferImpl(0));
        // Give the Compute instances a reference to the Filter
        // instances.
        bin1.setFilter(binFilter1);
        bin2.setFilter(binFilter2);
        bin3.setFilter(binFilter3);
        bin4.setFilter(binFilter4);
        bin5.setFilter(binFilter5);
        bin6.setFilter(binFilter6);
        bin7.setFilter(binFilter7);
        bin8.setFilter(binFilter8);

        // Start the filters.
        binFilter8.startFilter();
        binFilter7.startFilter();
        binFilter6.startFilter();
        binFilter5.startFilter();
        binFilter4.startFilter();
        binFilter3.startFilter();
        binFilter2.startFilter();
        binFilter1.startFilter();
        stnFilter2.startFilter();
        stnFilter1.startFilter();
        rtrFilter.startFilter();

        // Populate Router's input buffer
        Thread inputThread = new ChickenInputThread(rtrInput);
        inputThread.start();

        // -- FOR DEBUGGING --
        // Thread outputThread1 = new ChickenOutputThread(someBuffer, "(description)");
        // outputThread1.start();

    }

}