package elte.java2_utikalauz5.net;

import java.net.*;
import java.io.*;
import java.lang.Math;

/**
Egy olyan UDP-alapú kommunikációs végpont, amely nyugtázással és szükség szerinti újraküldéssel biztosítja
a <q>viszonylag</q> megbízható adatátvitelt.

@link.forrásfájl {@docRoot}/../data/net/src MegbizhatoEgyiranyuDatagramSocket.java
@since Java 2 Útikalauz programozóknak 1.3
*/
public class MegbizhatoEgyiranyuDatagramSocket
                extends FeledekenyDatagramSocket {

  private byte számláló=0; // az éppen elküldött csomag sorszáma
  private byte előzőleg_érkezett_csomag_számlálója=0;
  private boolean tmout_beállítva=false; // beállítottuk már az
                                         // időtúllépés figyelését?
  private boolean első_csomag=true; // fogadtunk már csomagot ezen a
                                    // kommunikációs végponton?

  public MegbizhatoEgyiranyuDatagramSocket() throws SocketException {
    super();
  }

  public MegbizhatoEgyiranyuDatagramSocket(int p) throws SocketException {
    super(p);
  }

  public MegbizhatoEgyiranyuDatagramSocket(int p, InetAddress la)
     throws SocketException {

    super(p,la);
  }

  private void inkrementál() {
    számláló=(byte)((számláló+1)%256); // 255-nél nullára forog át ...
  }

  private byte inkrementált(byte b) {
    return (byte)((b+1)%256);
  }

  // Egy bájt méretű segédadattal kiegészített UDP-csomag elküldése
  // Lényeg: az átküldeni kívánt csomag tartalmát egy új csomagba
  // másoljuk, és elől kiegészítjük az elküldeni kívánt bájttal.
  private void mb_send(DatagramPacket p, byte b) throws IOException {
    InetAddress ip_cím = p.getAddress();
    int server_port = p.getPort();
    int eredeti_üzenet_hossz = p.getData().length;
    byte[] eredeti_üzenet = p.getData();
    byte[] újüzenet = new byte[eredeti_üzenet_hossz+1];

    újüzenet[0]=b; // kiegészítjük az elküldeni kívánt bájttal
    for (int i=0;i<eredeti_üzenet_hossz;i++) {
      újüzenet[i+1]=eredeti_üzenet[i];
    }

    DatagramPacket sorszámozott_p=new DatagramPacket(újüzenet,
                           eredeti_üzenet_hossz + 1, ip_cím, server_port);
    super.send(sorszámozott_p); // Átadjuk az UDP protokollnak
  }

  // Egy bájt méretű segédadattal kiegészített UDP-adatcsomag fogadása.
  // Lényege: a megérkezett csomagból "kiszedjük" az első bájton levő
  // segédadatot, és az így maradt csomagtartalmat adjuk vissza a
  // hívónak.
  private byte mb_receive(DatagramPacket p) throws IOException {
    byte[] hely = new byte[65536]; // ez a potenciálisan legnagyobb
                                   // UDP-csomag méreténél is nagyobb
                         // de tkp. elég lenne p.getData().length is.
    DatagramPacket sorszámozott_p=new DatagramPacket(hely, 65536);
    super.receive(sorszámozott_p); // Fogadok egy UDP-csomagot
    if (sorszámozott_p.getLength() < 1) { // nulla hosszú csomag nem jó!
      super.receive(sorszámozott_p); // Fogadok egy újabb UDP-csomagot
    }
    p.setAddress(sorszámozott_p.getAddress());
    p.setPort(sorszámozott_p.getPort());

    byte[] eredeti_üzenet = p.getData(); // Kinyerem az érkezett adatokat
    byte[] érkezett_üzenet = sorszámozott_p.getData();
    // A hívónak az érkezett csomag tartalmát kell visszaadni, de ha
    // a hívó által a metódus paraméterben átadott csomag mérete
    // a szükségesnél rövidebb, akkor csak annyi karaktert adunk vissza.
    int másolás_hossza = java.lang.Math.min(eredeti_üzenet.length,
                                            érkezett_üzenet.length);
    for (int i=0;i<másolás_hossza;i++) {
      eredeti_üzenet[i]=érkezett_üzenet[i+1];
    }
    p.setLength(sorszámozott_p.getLength()-1);
    return érkezett_üzenet[0];
  }

  // Elküld egy csomagot, és megvárja a címzettől érkező nyugtát.
  public synchronized void nyugtázott_send(DatagramPacket p)
          throws IOException {

    inkrementál();   // Minden csomaggal új számláló értéket küldünk.
    byte üzenet_számláló=számláló;
    byte visszakapott_érték;
    boolean biztosan_megérkezett=false;
    byte[] tmp_buf=new byte[1];
    DatagramPacket q=new DatagramPacket(tmp_buf, 1); // Nyugtát fogadjuk

    if (!tmout_beállítva) {
      setSoTimeout(500);    // Ha még nem állítottuk be az adatcsomag
      tmout_beállítva=true; // fogadási időtúllépési határt, akkor most
    }                       // tesszük azt meg.
    while (!biztosan_megérkezett) { // Amíg nem biztos, hogy átért ...
      mb_send(p,üzenet_számláló);   // Elküldjük az aktuális sorszámmal
      // System.out.println("s:csomag elküldve ...");
      try {
        // System.out.println("s:nyugtára várva  ...");
        visszakapott_érték=mb_receive(q); // Várunk a partner nyugtájára
        // System.out.println("s:kaptam nyugtát ...");
        if (üzenet_számláló==visszakapott_érték) { // Jó nyugta érkezett?
          biztosan_megérkezett=true;               // Igen, jó nyugta ...
        }
      } catch (InterruptedIOException e) {
        // Időhatár túllépése esetén újra elküldjük
      }
      if (!biztosan_megérkezett) {
        // System.out.println("s:ÚJRAKÜLDÖM...");
      }
    }
  }

  // Beolvassa a következő csomagot, és nyugtát küld a feladónak.
  public synchronized void nyugtázott_receive(DatagramPacket p)
          throws IOException {

    byte visszakapott_érték;
    boolean vanújcsomag=false;  // Az előző csomag másodpéldánya?

    while (!vanújcsomag) {
      // Várakozunk egy adatcsomagra
      visszakapott_érték=mb_receive(p);
      // System.out.println("r:csomag érkezett...");
      // Kaptunk egy adatcsomagot
      if (első_csomag) {
        if (visszakapott_érték == 1) { // már az elején 1-re növeltük
          vanújcsomag=true;            // A várt csomag sorszámát előre
        }                              // ismerjük, nem számolni kell.
        első_csomag=false;
        előzőleg_érkezett_csomag_számlálója=visszakapott_érték;
      } else {
        if (inkrementált ( előzőleg_érkezett_csomag_számlálója ) ==
                     visszakapott_érték ) {

               // A fenti feltétel vizsgálata is elég ...
               vanújcsomag=true;       // Tényleg ez a csomag következik...
               előzőleg_érkezett_csomag_számlálója=visszakapott_érték;
        } else {
               // System.out.println("Duplázott/nem a várt csomag.");
        }
      }
      // Előkészítünk egy nyugtát; oda, ahonnan a csomagot kaptuk
      byte[] tmp_buf=new byte[1];
      DatagramPacket q=new DatagramPacket(tmp_buf, 1,
                                          p.getAddress(), p.getPort());
      // Visszaküldjük a nyugtát
      // System.out.println("r:nyugtát küldök...");
      mb_send(q,visszakapott_érték);
    }
  }
}