package csci3366sample.masterworker.sockets;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.net.Socket;

import csci3366sample.masterworker.FakeTasks;

/**
 *  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:  hostname for server, port number, 
 *  (optional) "--verbose" for verbose output
 *
 *  Worker for client/server versions using sockets.
 */
public class Worker {

    // variables/constants

    private String host;
    private int port;
    private boolean verbose;

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

        String usageMessage = "parameters:  host portNum [--verbose]";
        final int REQUIRED_PARMS = 2;
        String host = null;
        int port = 0;
        boolean verbose = false;

        /* process command-line arguments */
        if (args.length < REQUIRED_PARMS) {
            System.err.println(usageMessage); System.exit(1);
        }
        host = args[0];
        try {
            port = Integer.parseInt(args[1]);
        }
        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 Worker(host, port, verbose).doProcessing();
    }

    /** Constructor. */
    public Worker(String _host, int _port, boolean _verbose)
    {
        host = _host;
        port = _port;
        verbose = _verbose;
    }

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

        int totalTaskTime = 0;
        int numTasks = 0;

        Socket socket = null;
        ObjectInputStream input = null;
        ObjectOutputStream output = null;

        try {
            /* connect to master process */
            socket = new Socket(host, port);
            input = new ObjectInputStream(socket.getInputStream());
            output = new ObjectOutputStream(socket.getOutputStream());

            /* receive worker ID */
            int myID = (Integer) input.readObject();

            System.out.printf("worker %d starting\n", myID);

            /* process tasks until no more */
            Object fromMaster = null;
            while ((fromMaster = input.readObject()) instanceof FakeTasks.Task)
            {
                /* execute task and send result back */
                FakeTasks.Task t = (FakeTasks.Task) fromMaster;
                FakeTasks.TaskResult tr = t.execute();
                if (verbose) {
                    System.out.printf("worker %d received %s\n", 
                            myID, FakeTasks.toString(t, tr));
                }
                output.writeObject(tr);
                /* update local totals */
                ++numTasks;
                totalTaskTime += t.time;
            }
            /* send back summary result */
            output.writeObject(new Summary(numTasks, totalTaskTime));
            /* shut things down */
            socket.shutdownOutput();
            output.close();
            input.close();
            socket.close();
            System.out.printf("worker %d done\n", myID);
        }
        catch (ClassNotFoundException e) { 
            System.err.println("worker error:\n\t" + e);
        }
        catch (IOException e) { 
            System.err.println("worker error:\n\t" + e);
        }
    }

    /**
     * Class for returning summary results to master.
     */
    public static class Summary implements Serializable {
        private static final long serialVersionUID = 1L;

        public final int numTasks;
        public final int totalTaskTime;

        public Summary(int nTasks, int taskTime) {
            numTasks = nTasks; totalTaskTime = taskTime;
        }
     }
}