//mobile processing code

// thanks a lot to Francis Li from http://www.francisli.com/
// for mobile processing, Bluescan, the sample codes
// upon this project is built as well
//
// the rest was written by Johannes Landstorfer http://hannes.emotisys.de
//

// internal notice, when running on my local computer
// remove lock files (as root!) before starting emulator again!
// comcon-server.port.lock, WMAServer.ports.lock
// del d:\Java\wirelessToolkit\wtklib\*.lock


// basic setup & variables //////////////////////////////////////////////////////
import processing.image2.*;

import processing.bluetooth.*;
Bluetooth bt;



PFont standardfont;
color bgcolor;
color textcolor;



// specific variables ////////////////////////////////////////////////////////

// as arrays cant be expanded easily
// set the max length to the number of people taking part
// this might be obsolete once ArrayLists are in use
int participants = 20;

// define all "known" contacts here
// note: as arrays cant be expanded easily in mobile p5 choose an arbitrary length here
// and count the "filled slots" in an external variable
Contact[] contactlist = new Contact[participants];
int contactlist_len = 0;

// the collection process takes place in the background
// contacts_found_pre collects all devices/contacts as soon as they are detected
// at the end of each detection process it passes its contents to contacts_found and is reset
// so that only devices that are currently detectable are transfered in the next run
Contact[] contacts_found_pre = new Contact[participants];
int contacts_found_pre_len = 0;
// once detection is complete, "publish" the contacts here
Contact[] contacts_found = new Contact[participants];
int contacts_found_len = 0;

// store all "personal" symbols in an array
// the index in this array will correspond to the index of contactlist
PImage[] symbols = new PImage[participants];
int symbols_len = 0;
// when flipping through the images for display, this is the current index and the current image
int contact_onstage;
PImage symbol_onstage;

// fading variables
// the color of the layer that will fade in and out
color curtain_color;
// indicates whether the symbol has been exchanged (once per iteration)
boolean change_symbol = true;
// indicates whether fading-process is running or not
boolean fader_flag = false;
// steps from 0 to PI for sin-fading
int fader_currstep = 0;
// step-width, intended as float (range 0 - 3.14) but floats cant be assigned to vars (in mobile p5)
int fader_rate = 60 *PI/314; // in mobile p5 PI=804...

// setup of timer that will exchange the symbols on the screen
int showtime = 1500;
int timer_old = 0;
int timer_now = 0;





// variables more or less for debugging only
int devices_count = 0; // count number of all devices available via bt
int detectionruns_count = 1;  // count number of detection runs
String probe = "."; // a testing variable to check values on runtime



// processing /////////////////////////////////////////////////////////

void setup() {
  //setup the stage and apperance
  framerate (20);
  bgcolor = color(50, 50, 50);
  textcolor = color(200, 180, 0);

  standardfont = loadFont("ArialMT-10.mvlw", textcolor, bgcolor); //"ArialMT-10.mvlw";
  textFont (standardfont);
  background (bgcolor);

  // build a kind of fake address book
  // Contact (MAC-Adress of bluetooth device, name, symbol, position in the origininal list);
  //
  // (note on how p5code works):
  // it seems as the contactlist_len gets updated only after the [index] has been applied
  // but it is updated already in the "new Contact"construction
  contactlist[contactlist_len++] = new Contact ("000000000000", "he", "somepicture.png", contactlist_len-1);
  contactlist[contactlist_len++] = new Contact ("111111111111", "whoever", "somethingelse.png", contactlist_len-1);
  contactlist[contactlist_len++] = new Contact ("CCCCCCCCCCCC", "someone", "mysymbol.png", contactlist_len-1);

/*  */
  // preload all images as loading on runtime slows processing down
  // complicates selection of images later a bit (> field "origindex" in Contact class)
  for (int c=0; c<contactlist_len; c++) {
    symbols[c] = loadImage(contactlist[c].pict);
    symbols_len++;
  }

  // initalize a new Bluetooth object
  bt = new Bluetooth(this);
  // start the first bt-discovery
  // will be called from within librayEvent from now on
  bt.discover();

}



void draw() {
  //wipe the screen
  background (bgcolor);

  // print variables for debugging
  text("devices: " + str(devices_count) + " // contacts: " + str(contacts_found_pre_len )+ " // run " + str(detectionruns_count), 0, 10);
  //text(probe, 0, 20);

  // start timer
  int timer_now = millis();

  // show each image from contacts_found for [showtime] millis
  if (timer_now >= timer_old + showtime) {
    fader_flag = true;
    timer_old = timer_now;
  }

  // fading-speed will be timed by the built-in framerate() and fader_rate
  if (fader_flag == true) {
    // use positive-half of sinus (<PI) to fade
    if (fader_currstep < ((int)(PI)) - fader_rate) {
      fader_currstep += fader_rate;
    }
    else {
      // once the loop is finished, reset all variables
      fader_currstep = 0;
      change_symbol = true;
      fader_flag = false;
    }
    // change symbols behind the curtain on half way ("sin(x) = 1")
    // a once-per-loop event
    if (fader_currstep > ((int)(PI/2)) && change_symbol == true) {
      if (contact_onstage < contacts_found_len - 1)
        contact_onstage++;      // select next symbol
      else
        contact_onstage = 0;    // or start with the first one again
      change_symbol = false;
    }
  }

  // we dont know if we will find friends (esp. not before the first detection is complete)
  if (contacts_found[contact_onstage] != null)
    symbol_onstage = symbols[contacts_found[contact_onstage].origindex];

  // if something went wrong in the image construction, we cant show anyth.
  if (symbol_onstage != null) {

/* resize would be nice but needs more tweaking because "createImage" is not available in mobilep5
    //img.copy(srcImg, startx, starty, startwidth, startheight,
    //         destx, desty, destwidth, destheight);
    PImage symbol_onstage = createImage(150, 200, RGB);
    copy(symbol_small, 0, 0, symbol_small.width, symbol_small.height, 0, 0, symbol_onstage.width, symbol_onstage.height);
*/
    // show the image centered on the screen
    image(symbol_onstage, width/2 - symbol_onstage.width/2, height/2 - symbol_onstage.height/2);
  }

  // construct a new layer to fade in and out above the original image
  PImage2 curtain = new PImage2 (width, height);
  color curtain_color = color (bgcolor, (int)(sin(fader_currstep))); // sin(PI) = 255 in mobile p5
  curtain.loadPixels();
  for (int p=0; p<curtain.width*curtain.height; p++) {
     curtain.pixels[p] = curtain_color;
  }
  // p5 needs a curtain.updatePixels(); here. not available in p5; not necessary either
  image(curtain, 0, 0);


/*debugging:
  for (int d=0; d<getLength(contacts_found_pre); d++) {
    text(contacts_found_pre[d], 0, 60+d*10);
  }
*/
}



void libraryEvent(Object library, int event, Object data) {
  // if library is an object as bt is, why do the equal with "==" instead of "equals"?
  if (library == bt) {

    switch (event) {
    case Bluetooth.EVENT_DISCOVER_DEVICE:
      devices_count++;

      Device device = (Device) data;
      // debugging:
      //text("there is " + device.name + " // " + device.address + " // " + detectionruns_count + ".run", 0, 60+curr_devices_count*20);

      // if device is known add contact to the list of contacts_found
      for (int c=0; c<contactlist_len; c++) {

      if (!contactlist[c].address.equals(device.address))
          continue; //not found in the contactlist (unknown), so skip

        // debugging: name of the device that is currently processed
        probe = "handle: " + contactlist[c].name;
        // the address is known (in contactslist), so add it to the found Contacts if new
        // already on the list?
        if (contacts_found_pre_len == 0) {
          // nothing in the array so far, so make first entry
          ////addContact(contacts_found_pre, contactlist[c], contacts_found_pre_len);
          contacts_found_pre[contacts_found_pre_len] = contactlist[c];
          contacts_found_pre_len++;
          break;
        }

        // check whether the device/contact is already in the list
        for (int d=0; d<contacts_found_pre_len; d++) {
          if (contacts_found_pre[d].address.equals(device.address))
            break; // already in the list

          // append to list because it's new
          ////addContact(contacts_found_pre, contactlist[c], contacts_found_pre_len);
          contacts_found_pre[contacts_found_pre_len] = contactlist[c];
          contacts_found_pre_len++;
          break; // no need to continue the loop, because we put the device as a new contact on the list
        }
        break;
      }  // end of for(c)
      break;  // end of case EVENT_DISCOVER_DEVICE

    case Bluetooth.EVENT_DISCOVER_DEVICE_COMPLETED:
      // debugging:
      // text(devices.length + " devices discovered. " + detectionruns_count + ". run", 0, (curr_devices_count+1)*20);

      // "publish" all found contacts, ie. make them available to draw()
      contacts_found = contacts_found_pre;
      contacts_found_len = contacts_found_pre_len;
      /* dummy entries when working with one discoverable bt-device only
      contacts_found[contacts_found_len] = contactlist[1];
      contacts_found_len++;
      contacts_found[contacts_found_len] = contactlist[2];
      contacts_found_len++;
      */

      // reset the working array and the device counter
      contacts_found_pre = new Contact[participants];
      contacts_found_pre_len = 0;
      // count number of detection runs (can be used for debugging)
      detectionruns_count++;
      devices_count = 0;
      // run discover again, which will trigger the libraryEvent again
      bt.discover();
      break;
    } // end of switch()
  } // end of if(library == bt)
}



// custom classes /////////////////////////////////////////////////////////

// a Contact is another users that are defined as "known"
// the object "Contact" holds all necessary data
// it will ususally be used as an array which serves as a contactlist
class Contact {
  String address; // the MACaddress (as String)
  String name; // real-world name of the Contact
  String pict; // filename for symbol that is used by this Contact
  int origindex; // position/index of a Contact in the original contactlist
                 // (useful for selections made from contactlist, e.g. contacts_found)

  // constructor
  Contact (String a, String n, String p, int o) {
      address = a;
      name = n;
      pict = p;
      origindex = o;
    }
}



// custom functions /////////////////////////////////////////////////////////


// getLength (or length() ) has to be used with mobile p5
// as the direct approach via .length won't work in many cases
// thanks to xibra on http://mobile.processing.org/discourse/YaBB.cgi?board=softbugs;action=display;num=1127926063
int getLength(Object[] o) {
  return o.length;
}



// documentation of alternative ideas to expand an array that did not work

// adds new records to Arrays of Contacts
// a modification of the routines found in bluescan of Francis Li
// www.francisli.com
//// not working for me as intended (I want to use the same routine for different variable names)
//// ArrayList or Vector would help
/*
void addContact (Contact[] orig_array, Contact new_entry, int arraycounter) {

  orig_array[arraycounter] = new_entry;
  arraycounter++;

  // if all slots are filled, double the size of the array
  // one empty slot would be enough but with dubbling we have less processing load
  // like expand() which does not work with Objects in mobile p5
  if (getLength(orig_array) == arraycounter) {
    Contact[] old_array = orig_array;
    orig_array = new Contact[2*arraycounter];
    arraycopy(old_array, 0, orig_array, 0, arraycounter); // (src, src_start, dst, dst_start, src_len)
  }

  // make the new values "publicly" available
  if (orig_array == contactlist) {
    contactlist = orig_array;
    contactlist_len = arraycounter;
  }
  if (orig_array == contacts_found) {
    contacts_found = orig_array;
    contacts_found_len = arraycounter;
  }
  if (orig_array == contacts_found_pre) {
    contacts_found_pre = orig_array;
    contacts_found_pre_len = arraycounter;
  }
}

void addPImage (PImage[] orig_array, String new_entry, int arraycounter) {

  orig_array[arraycounter] = loadImage(new_entry);
  arraycounter++;

  // if all slots are filled, double the size of the array
  // one empty slot would be enough but with dubbling we have less processing load
  // like expand() which does not work with Objects in mobile p5
  if (getLength(orig_array) == arraycounter) {
    PImage[] old_array = orig_array;
    orig_array = new PImage[2*arraycounter];
    arraycopy(old_array, 0, orig_array, 0, arraycounter); // (src, src_start, dst, dst_start, src_len)
  }

  // make the new values "publicly" available
  if (orig_array == symbols) {
    symbols = orig_array;
    symbols_len = arraycounter;
  }
}
*/

/*
//// nicer solution to add values to Object-Arrays but
//// this works only in processing, p5 mobile cant expand Object[]s.
// customized function to append an Object to an Object Array
// the built in append() only accepts primitives (int, char, ...) and Strings
// but not Arrays or Objects
Object[] array_push (Object[] orig_array, Object new_entry) {
  // the getLength is necessary for mobile processing as .length is buggy there
  int arraylength_before = getLength(orig_array);
  // make sure to have an Object[] as result (expand() returns Arrays? by default)
  orig_array = (Object[]) expand(orig_array, arraylength_before+1);
  // put the new entry into the created "slot" of the array
  orig_array[arraylength_before] = new_entry;
  return orig_array;
}
*/