package elte.java2_utikalauz5.rmi;

import java.rmi.server.UnicastRemoteObject;
import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.RMISecurityManager;
import java.util.Vector;
import java.util.Hashtable;

/**
Egy naptár feladatait megvalósító osztály.
Főprogramja létrehoz egy új üres naptár objektumot, és bejegyzi
az RMI névszolgáltatójába. A naptár tulajdonosának a nevét az egyetlen
programparaméterben várja, ezen a néven jegyzi be a naptár objektumot a
névszolgáltatóba.

Használatakor ne feledjünk el a következő jogokat megadni!
<pre>
grant signedBy "utikalauz" {
  permission java.security.AllPermission;
};
</pre>

@link.forrásfájl {@docRoot}/../data/rmi/src Naptar.java
@link.letöltés {@docRoot}/../data/rmi Naptar.jar
@since Java 2 Útikalauz programozóknak
*/
public class Naptar extends UnicastRemoteObject
  implements NaptarInterface, TranzakcioResztvevoInterface {

    /** Verziószám. */
    private final static long serialVersionUID = 15L;

  String tulajneve; // A naptár tulajdonosának neve
  Hashtable<String, String> elfoglaltsag; // (DatumString, String)
  Hashtable<String, java.util.Vector<String>> visszacsinal; // (Tid, Vektor(DatumString)) párok; ezek jelzik,
                          // hogy mikor is módosított az illető tranzakció
  Hashtable<String, String> kommittalhat; // (Tid, Valami) pár, amelyik tranzakció már
                          // biztosan nem véglegesíthető.
  private static Object mutex = new Object(); // Kölcsönös kizáráshoz

  // A konstruktor művelet létrehoz egy üres naptárat
  public Naptar(String tulajneve) throws RemoteException {
    super(); // FONTOS, ezzel lesz távolról elérhető az objektum
    this.tulajneve=tulajneve;
    this.elfoglaltsag=new Hashtable<String, String>();
    this.visszacsinal=new Hashtable<String, java.util.Vector<String>>();
    this.kommittalhat=new Hashtable<String, String>();
    // üres naptár elkészült ...
  }

  // Ezzel lehet egy adott időpontra egy elfoglaltságot bejegyezni
  public void Lefoglal(String mikor, String mi,
                       TranzakcioManagerInterface ti)
                       throws java.rmi.RemoteException {

    // Értesíti a koordinátort, hogy ebben a tranzakcióban
    // résztvevőként tartsa nyilván ezt az objektumot is.
    ti.Tranzakcio_Resztvevo_Bejegyzese(tulajneve,this);
    // Kölcsönösen kizárjuk az esetleges párhuzamos módosításokat
    synchronized (mutex) {
      // Ha erről a tranzakcióról még nem tárolunk adatokat,
      // akkor létrehozzuk a szükséges állapothordozókat.
      if (!(visszacsinal.containsKey(ti.getTid()))) {
        Vector<String> umodositasok=new Vector<String>();
        visszacsinal.put(ti.getTid(), umodositasok);
        umodositasok=null;
      }

      // Megnézzük, hogy szabadok vagyunk-e még a
      // a kérdéses napon.
      if (elfoglaltsag.containsKey(mikor)) {
        // Ha a kérdéses nap már foglalt, akkor nem
        // jegyzünk be semmit, hanem
        // abortáljuk a tranzakciót (MAJD)
        // (Mindegy mit tárolunk a 2. paraméterben!)
        kommittalhat.put(ti.getTid(),mikor);
        return; // vissza a hívóhoz ...
      }

      // Eltároljuk, hogy mikorra jegyzett be elfoglaltságot
      // az illető tranzakció.
      Vector<String> modositasok=visszacsinal.get(ti.getTid());
      modositasok.insertElementAt(mikor,modositasok.size());
      // És be is jegyezzük, nehogy másvalaki bejegyezzen
      // valami más elfoglaltságot.
      elfoglaltsag.put(mikor,mi);
      System.out.println("Lefoglalási kísérlet:"+mikor.toString()+
                         "-kor elfoglaltság:"+mi);
    }
  }

  // Egy abortált tranzakció tevékenységeit semlegesítjük
  private void Visszacsinal(String tid) {
    int index;

    // Megszerezzük a módosítások listáját
    Vector modositasok=(Vector) visszacsinal.get(tid);
    index=0;
    for (index=0;index<modositasok.size();index=index+1) {
      // Kinyerjük a módosítás dátumát
      String o=(String) (modositasok.elementAt(index));
      // Töröljük az elfoglaltságok közül
      elfoglaltsag.remove(o);
    }
  }

  // Itt következnek a kétfázisú megegyezést támogató metódusok

  // Első fázis: a tranzakció rám eső részét tudom-e véglegesíteni?
  public boolean Felkeszul(String tid) throws java.rmi.RemoteException {
    if (kommittalhat.containsKey(tid)) {
      return false; // Nem véglegesíthető (ui. ütközött valamivel)
    } else {
      return true; // Nem volt ütközés, véglegesíthető
    }
  }

  // Második fázis: a tranzakció rám eső részét véglegesíteni kell vagy
  // vissza kell csinálni ... (b=igaz/hamis attól függően, mi is a teendő)
  public void Veglegesit(boolean b, String tid)
    throws java.rmi.RemoteException {

    if (!b) {
      Visszacsinal(tid); // Nem véglegesíthető ...
    }
    // Töröljük a tranzakcióról tárolt dolgokat, már nem kellenek
    visszacsinal.remove(tid);
    kommittalhat.remove(tid);
    System.out.println(tid+" tranzakció lezárva.");
  }

  // Kétfázisú megegyezést támogató metódusok vége

  public static void main(String args[]) {
    System.setSecurityManager(new RMISecurityManager());
    try {
      // Létrehozunk egy új üres naptár objektumot
      Naptar n = new Naptar(args[0]);
      // Az új naptárat bejegyezzük az args[0]-ban
      // megadott néven a névszolgáltatóba
      // Konvenció: args[0] a naptár tulajdonosának a neve
      Naming.rebind(args[0],n);
      System.out.println(args[0]+" naptára aktív!");
    } catch (Exception e) {
      System.out.println(args[0]+" naptárat nem lehetett létrehozni!");
    }
  }
}