package csci3366sample.masterworker.sockets;

import java.io.IOException;
import java.io.Serializable;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.List;

/**
 *  Generic example of master/worker program.
 *  "Tasks" just consist of sleeping for a specified time; times to wait are
 *  generatedly randomly from 1 to a specified maximum.
 *
 *  Command-line arguments:  total tasks, maximum task time, port number,
 *  number of workers, (optional) "--verbose" for verbose output
 *
 *  Master process for client/server version using sockets and a somewhat 
 *  centralized approach (with the number of workers known to the server).
 */
public class Master1 extends Master {

    /* variables/constants */

    int port;
    int numWorkers;

    /**
     * Main method.
     */
    public static void main(String[] args) {

        String usageMessage = 
            "parameters:  numTasks maxTaskTime portNum numWorkers [--verbose]";
        final int REQUIRED_PARMS = 4;

        int numTasks = 0;
        int maxTaskTime = 0;
        int port = 0;
        int numWorkers = 0;
        boolean verbose = false;

        /* process command-line arguments */
        if (args.length < REQUIRED_PARMS) {
            System.err.println(usageMessage); System.exit(1);
        }
        try {
            numTasks = Integer.parseInt(args[0]);
            maxTaskTime = Integer.parseInt(args[1]);
            port = Integer.parseInt(args[2]);
            numWorkers = Integer.parseInt(args[3]);
        }
        catch (NumberFormatException e) {
            System.err.println(usageMessage); System.exit(1);
        }
        if (args.length > REQUIRED_PARMS) {
            if (args[REQUIRED_PARMS].equals("--verbose"))
                verbose = true;
            else {
                System.err.println(usageMessage); System.exit(1);
            }
        }
       
        /* do processing */
        new Master1(
                numTasks, maxTaskTime, port, numWorkers, verbose).doProcessing();
    }

    /** Constructor. */
    public Master1(int _numTasks, int _maxTaskTime, 
            int _port, int _numWorkers, boolean _verbose)
    {
        super(_numTasks, _maxTaskTime, _port, _verbose);
        numWorkers = _numWorkers;
        port = _port;
    }

    /** Do processing. */
    public void doProcessing() {

        initialize();

        /* accept connections for specified number of workers */
        if (verbose) {
            System.out.println("waiting for workers");
        }
        Socket[] workers = new Socket[numWorkers];
        try {
            ServerSocket ss = new ServerSocket(port);
            for (int i = 0; i < workers.length; ++i) {
                workers[i] = ss.accept();
                if (verbose) {
                    System.out.printf("connection from %s, worker %d\n", 
                            clientAddress(workers[i]), i);
                }
            }
        }
        catch (IOException e) {
            System.err.println("error setting up server/workers:\n\t" + e);
            System.exit(1);
        }

        /* start timing */
        long startTime = System.currentTimeMillis();

        /* build queue of tasks */
        buildTaskQueue(numTasks, maxTaskTime);

        /* create threads for workers */
        Thread[] threads = new Thread[numWorkers];
        for (int i = 0; i < threads.length; ++i) {
            threads[i] = new Thread(new WorkerTalker(i, workers[i]));
        }

        /* start them up */
        for (int i = 0; i < threads.length; ++i) {
            threads[i].start();
        }

        /* wait for them to finish */
        for (int i = 0; i < threads.length; ++i) {
            waitForThreadToComplete(threads[i]);
        }

        /* end timing and print result */
        long endTime = System.currentTimeMillis();
        System.out.printf(
                "\nsockets-based client/server version with %d workers\n",
                numWorkers);
        printSummaryInfo(numTasks, maxTaskTime);
        System.out.printf("running time = %g\n", 
                (double) (endTime - startTime) / 1000);
    }
}