/**
 *  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, seed,
 *  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).
 */
package csci3366.sample.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;

import csci3366.sample.masterworker.sockets.Master;

public class Master1 extends Master {

    /* variables/constants */

    int port;
    int numWorkers;

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

        String usageMessage = 
            "parameters:  numTasks maxTaskTime seed portNum numWorkers [--verbose]";

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

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

    /** Constructor. */
    public Master1(int numTasks_, int maxTaskTime_,  int seed_,
            int port_, int numWorkers_, boolean verbose_)
    {
        super(numTasks_, maxTaskTime_, seed_, 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, seed);

        /* 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);
    }
}