package rmi;
import java.io.*;
import java.rmi.*;

public interface IMBroker extends Remote {
    //public String viewOrder(int tableNumber);
    //public void changeOrderStatus(int tableNumber);
    //public void foodIsReady(int tableNumber);
    public String helloWorld() throws RemoteException;
}


package domain.mediator;

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.Observable;
import java.util.Observer;

import rmi.MyRemote;

import acquaintance.AErrorDialog;
import acquaintance.AIReservation;

import foundation.*;
import domain.entity.*;

public class MBroker extends UnicastRemoteObject implements IMBroker {

    RestaurantCity rc;
    FConnection con;
    Food[] foodList;
    FReader reader;
    FWriter writer;

    //Kalder den rigtige constructor
    public MBroker() throws RemoteException {
        this(new FConnection());
    }

    //constructor, skaber forbindelse til databasen (foundation)
    public MBroker(FConnection con) throws RemoteException {
        rc = new RestaurantCity();
        this.con = con;
        reader = con.getReader();
        writer = con.getWriter();
    }
    public MBroker(FConnection con, RestaurantCity rc) throws RemoteException{
        this.con = con;
        this.rc = rc;
        reader = con.getReader();
        writer = con.getWriter();
    }
    public FConnection getFConnection(){
        return con;
    }
    public RestaurantCity getRestaurantCity(){
        return rc;
    }

    //Brugsmønster B01 "opret bestilling"
    public void makeOrder(int tableNumber, Food[] foods, String comment) {
        //Kalder først metoden i RC
        rc.makeOrder(tableNumber, foods, comment);

        //Opretter en unix epoch date dato til databasen
        String date = Long.toString(System.currentTimeMillis());

        //Kommaseparerer retterne
        String str = new String();
        for(Food mad : foods){
            str += "," + mad.getID();
        }

        //Tilføjer til databasen.
        try {
            writer.executeUpdate("INSERT INTO orders (tablenumber, food, comment, date) VALUES ('" + tableNumber + "','" + str.substring(1) + "','" + comment + "','" + date +"')");
        } catch (SQLException e) {
            new AErrorDialog(e.getMessage());
        }
    }

    //brugsmønster B12 - se bestilling
    public String viewOrder(int tableNumber){
        return rc.viewOrder(tableNumber);
    }

    //Brugsmønster B04 - betaling
    public String pay(int tableno) {
        String kvit = rc.pay(tableno);
        return kvit;
    }

    //Undersøger om et bord er betalt
    public boolean getPaymentStatus(int tableNumber){
        return rc.getPaymentStatus(tableNumber);
    }

    //Returnerer alle retter (bruges internt i Actioner eller Broker
    public Food[] getFoods(){
        ArrayList<Food> foodArray = new ArrayList<Food>();
             try {
                 //Henter alle retter
                 ResultSet rs = reader.executeQuery("SELECT * FROM food ORDER BY id ASC");
                 while (rs.next()){
                     Food food = null;
                     int foodId = rs.getInt(1);
                     String name = rs.getString("navn");
                     double price = Double.parseDouble(rs.getString("pris"));
                     int slags = Integer.parseInt(rs.getString("slags"));

                     //Afhængigt af slagsen (typen, kategorien), laves det rigtige objekt.
                     if(slags == 0){
                         food = new Beverage(foodId, name, price);}
                     if(slags == 1){
                         food = new Appetizer(foodId, name, price);}
                     if(slags == 2){
                         food = new Maindish(foodId, name, price);}
                     if(slags == 3){
                         food = new Dessert(foodId, name, price);}
                     if(slags == 4){
                         food = new Accessory(foodId, name, price);}

                     foodArray.add(food);
                }

             }
             catch(Exception e) {
                    new AErrorDialog("Exception: " + e.getMessage());
             }

             //Laver arraylisten om til et array og returnerer det.
             foodList = foodArray.toArray(new Food[0]);
             return foodList;

    }

    //Brugsmønster B06 - opret reservation (denne med password)
    public void makeReservation(int phoneno, Date reservationDate,int numberOfPersons, String password) {
        Reservation reservation = rc.makeReservation(phoneno, reservationDate, numberOfPersons, password);

        //Parser datoen
        DateFormat df = new SimpleDateFormat("HH:mm dd/MM-yyyy");
        String timeDate = df.format(reservationDate);

        int reservationID = reservation.getReservationID();
        try {
        //Indsætter i tabellen
        writer.executeUpdate("INSERT INTO reservations (Telefonnummer, Dato, AntalPersoner, Password, ReservationsID)" +
                "VALUES ('"+phoneno+"','"+timeDate+"','"+numberOfPersons+"','"+password+"','"+reservationID+"')");
        }
        catch(Exception e) {
            new AErrorDialog(e.getMessage());
        }
    }

    //Brugsmønster B06 - opret reservation (læs kommentarer ovenover)
    public void makeReservation(int phoneno, Date reservationDate,int numberOfPersons){
        Reservation reservation = rc.makeReservation(phoneno, reservationDate, numberOfPersons);

        DateFormat df = new SimpleDateFormat("HH:mm dd/MM-yyyy");

        String timeDate = df.format(reservationDate);
        int reservationID = reservation.getReservationID();
        try {
            // reservations (id, telefonnummer, dato, antalpersoner, password, reservationid)

            writer.executeUpdate("INSERT INTO reservations (telefonnummer, dato, antalPersoner, reservationsID)" +
            "VALUES ('"+phoneno+"','"+timeDate+"','"+numberOfPersons+"','"+reservationID+"')");
            }
        catch(Exception e) {
            new AErrorDialog(e.getMessage());
        }
    }

    //Fjerner reservation fra databasen. Bruges ved "tildel reservation"
    public void removeReservation(int reservationID){
        try{
        writer.executeUpdate("DELETE FROM reservations WHERE reservationsID='"+reservationID+"'");
        }
        catch(Exception e) {
            new AErrorDialog(e.getMessage());
        }
    }

    //Henter alle reservationer fra databasen
    public Reservation[] getReservations(){
        ArrayList<Reservation> reservationsArray = new ArrayList<Reservation>();
        try{
            ResultSet rs = reader.executeQuery("SELECT * FROM reservations ORDER BY id ASC");
             while (rs.next()){
                Reservation reservation = null;
                int phoneno = Integer.parseInt(rs.getString("telefonnummer"));
                DateFormat df = new SimpleDateFormat("HH:mm dd/MM-yyyy");
                Date timeDate = df.parse(rs.getString("dato"));
                int numberOfPersons = Integer.parseInt(rs.getString("antalPersoner"));
                String password = rs.getString("password");
                int reservationID = Integer.parseInt(rs.getString("reservationsID"));

                //Opretter reservationen med de hentede data og sætter det korrekte ID.
                reservation = new Reservation(phoneno, timeDate, numberOfPersons, password);
                reservation.setReservationID(reservationID);
                reservationsArray.add(reservation);
             }
        }
        catch(Exception e) {
            new AErrorDialog(e.getMessage());
        }
        //Returnerer det som et rigtigt array (fra ArrayList)
         return reservationsArray.toArray(new Reservation[0]);
    }

    //Undersøger om bordet er optaget
    public boolean getTableAvailabillity(int tableNumber){
        return rc.getTableAvailabillity(tableNumber);
    }

    //Sætter et bord til optaget, med reservationsID
    public void assignTable(int tableNumber, int reservationID){
        rc.assignTable(tableNumber, reservationID);
    }

    //Sætter et bord til optaget
    public void assignTable(int tableNumber){
        rc.assignTable(tableNumber);
    }

    //Sætter et bord klar
    public void clearTable(int tableNumber){
        rc.clearTable(tableNumber);
    }

    //Tilføjer Observers til RC
    public void addTableObserver(Observer o) {
        rc.addObserver(o);
    }

    //Ændrer den interne ordre status
    public void changeOrderStatus(int tableNumber){
        rc.changeOrderStatus(tableNumber);
    }

    //Fjerner en ordre
    public void removeOrder(int tableNumber){
        rc.removeOrder(tableNumber);
    }

    //Sætter maden klar. B13
    public void foodIsReady(int tableNumber){
        rc.foodIsReady(tableNumber);
    }
    public String seeDoneOrders(int tableno){
        return rc.seeDoneOrders(tableno);
    }

    //Brugsmønster 08 - Analyse af ordre
    public double[][] makeOrderAnalysis() {


        ResultSet rs;

        try {
            //Lav en dato så vi kun henter tom. 2009
            DateFormat df1 = new SimpleDateFormat("dd/MM-yyyy");
            Date dato = df1.parse("31/05-2009");
            Calendar kalendar = Calendar.getInstance();
            kalendar.setTime(dato);
            String strTime = Long.toString(kalendar.getTimeInMillis());

            //Henter alle ordre fra databasen, og lægger det ind i "ordre"
            rs = reader.executeQuery("SELECT food, date FROM orders WHERE date < "+ strTime);
            ArrayList<String[]> ordre = new ArrayList<String[]>();

            while (rs.next()) {
                String date = rs.getString("date");
                String food = rs.getString("food");
                String[] tmpArray = {date,food};
                ordre.add(tmpArray);
            }
            //Henter alle foods, som bruges til at bestemme slags mad
            Food[] allFoods = getFoods();

            //Array til at gemme antal retter ([5] = år, [28] = dage)
            int[][] data = new int[5][28];

            //Gennemløber alle ordre
            for (String[] singleOrder : ordre) {
                //Finder dag og år pr. ordre
                String time = singleOrder[0];
                String food = singleOrder[1];
                Calendar kalender = Calendar.getInstance();
                kalender.setTimeInMillis(Long.parseLong(time));
                DateFormat df = new SimpleDateFormat("dd");
                DateFormat fd = new SimpleDateFormat("yyyy");
                int day = Integer.parseInt(df.format(kalender.getTime()));
                int year = Integer.parseInt(fd.format(kalender.getTime()));

                //Tæller antal gyldige retter i ordren
                int dishes = 0;
                String[] mad = food.split(",");
                for (String strFoodID : mad) {
                    int foodId = Integer.parseInt(strFoodID)-1;
                    if (allFoods[foodId].getCategory() > 0 && allFoods[foodId].getCategory() < 4) {;
                        dishes++;
                    }
                }
                data[Math.abs(2005-year)][day-1] += dishes;

            }

            //Gør resultat arrays klar
            double[] sampleMean = new double[28];
            double[] sampleVarians = new double[28];
            double konfidensTop[] = new double[28];
            for (int i = 0; i < 28; i++) {
                sampleMean[i] = 0;
                sampleVarians[i] = 0;
                konfidensTop[i] = 0;
            }

            //Udregner sample mean
            for (int y = 0; y < data.length; y++) {
                for (int d = 0; d < data[y].length; d++) {
                    sampleMean[d] += (1/(Double.parseDouble(Integer.toString(data.length))))*data[y][d];
                }
            }

            //Udregner varians
            for (int y = 0; y < data.length; y++) {
                for (int d = 0; d < data[y].length; d++) {
                    sampleVarians[d] += (1/(Double.parseDouble(Integer.toString(data.length))-1))*Math.pow((data[y][d]-sampleMean[d]),2);
                }
            }

            //Beregner konfidensintervallet  alpha er 0.05
            double z = 1.96;
            double n = data.length;

            for (int m = 0; m < sampleVarians.length; m++) {
                konfidensTop[m] = sampleMean[m]+(Math.sqrt(sampleVarians[m])/Math.sqrt(n))*z;
            }

            //Returnerer output
            double[][] output = {sampleMean, konfidensTop};
            return output;

        } catch (Exception e) {
            new AErrorDialog(e.getMessage());
            return null;
        }
    }

    public void changeOrderstatus(int tableNumber) throws RemoteException {
        // TODO Auto-generated method stub

    }

    public MBroker getBroker() throws RemoteException {
        // TODO Auto-generated method stub
        return null;
    }

    public String Hej() throws RemoteException {
        // TODO Auto-generated method stub
        return null;
    }

    public String helloWorld() throws RemoteException {
        String str = "Hello world";
        System.out.println(str);
        return str;
    }
}


package rmi;


import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.Observer;

public class Client {

    public Client() {
    }

    public void Hej() {
        try {
            Registry registry = LocateRegistry.getRegistry(9999);
            MyRemote stub = (MyRemote) registry.lookup("dej");

            String response = stub.Hej();
            System.out.println("response: " + response);
        } catch (Exception e) {
            System.err.println("Client exception: " + e.toString());
            e.printStackTrace();
        }
    }
    public IMBroker getBroker() {
        try {
            Registry registry = LocateRegistry.getRegistry(9999);

            IMBroker response = (IMBroker) registry.lookup("dej");
            System.out.println(response.helloWorld());
            return response;
        } catch (Exception e) {
            System.err.println("Client exception: " + e.toString());
            e.printStackTrace();
            return null;
        }
    }

    public String viewOrder(int tableNumber){
        String response = null;
        /*try {
            Registry registry = LocateRegistry.getRegistry(1099);
            MyRemote stub = (MyRemote) registry.lookup("yello");

            response = stub.viewOrder(tableNumber);
            System.out.println("response: " + response);
        } catch (Exception e) {
            System.err.println("Client exception: " + e.toString());
            e.printStackTrace();
        }*/
    return response;
    }
    public void foodIsReady(int tableNumber){
        /*
        try {
            Registry registry = LocateRegistry.getRegistry(1099);
            MyRemote stub = (MyRemote) registry.lookup("yello");

            stub.foodIsReady(tableNumber);

        } catch (Exception e) {
            System.err.println("Client exception: " + e.toString());
            e.printStackTrace();
        }*/
    }
    public void changeOrderstatus(int tableNumber){
        /*
        try {
            Registry registry = LocateRegistry.getRegistry(1099);
            MyRemote stub = (MyRemote) registry.lookup("yello");

            stub.changeOrderstatus(tableNumber);

        } catch (Exception e) {
            System.err.println("Client exception: " + e.toString());
            e.printStackTrace();
        }*/
    }
    public void addTableObserver(Observer o){
        /*
        try {
            Registry registry = LocateRegistry.getRegistry(1099);
            MyRemote stub = (MyRemote) registry.lookup("yello");

            stub.addTableObserver(o);

        } catch (Exception e) {
            System.err.println("Client exception: " + e.toString());
            e.printStackTrace();
        }*/
    }
}



package rmi;

import java.rmi.*;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.Observer;
import java.rmi.server.UnicastRemoteObject;

import domain.mediator.MBroker;

public class Server implements MyRemote {
    MBroker broker;


    public Server(MBroker broker) throws RemoteException{
        this.broker = broker;
    }
    public String viewOrder(int tableNumber){
        return broker.viewOrder(tableNumber);
    }

    public void foodIsReady(int tableNumber){
        broker.foodIsReady(tableNumber);
    }

    public void changeOrderstatus(int tableNumber){
        broker.changeOrderStatus(tableNumber);
    }

    public void addTableObserver(Observer o) throws RemoteException {
        broker.addTableObserver(o);
    }
    public String Hej(){
        return "HEJ";
    }
    public MBroker getBroker(){
        return broker;

    }

        public void go(){
            try {
                Server obj = new Server(broker);
                MyRemote stub = (MyRemote) UnicastRemoteObject.exportObject(obj, 0);

                // Bind the remote object's stub in the registry
                //Registry registry = LocateRegistry.getRegistry();
                Registry registry = LocateRegistry.createRegistry(9999);
                registry.rebind("dej", broker);

                System.err.println("Server ready");
            } catch (Exception e) {
                System.err.println("Server exception: " + e.toString());
                e.printStackTrace();
            }
    }
}