//BT IRELAND MTM,Destination CID Name,VIA,Calls,MINS,ALOC,% User,ASR,NER 02
boolean DEBUG=true;

import proxml.*;

//java.io.NotSerializableException: geomerative.RShape

// ATTEMPT TO SERIALISE COUNTRY DATA.. unfinished
//
// use proxml manually
//

class country{
  String name;
  float calls,mins;
  transient RShape outline;
  country() {
    super();
  }
  country(String n,float c,float m,RShape shp){
    name=n;
    calls=c;
    mins=m;
    outline=shp;
  }
  void addnetwork(float c,float m) {
    calls+=c;
    mins+=m;
  }
  void printOut() {
    println(name+" "+calls+" "+mins);
  }
  RPoint getpoint(int tries){
      RPoint tl=outline.getTopLeft();
      RPoint br=outline.getBottomRight();
      RPoint np= new RPoint(0,0);
      int searching =1;
      while (searching>0&&searching<tries) {
        np=new RPoint(random(tl.x,br.x),random(tl.y,br.y));
        if(outline.contains(np)) searching=0;
        //if (DEBUG) println(name+"; try  "+searching+": "+np.x+","+np.y+" bounds: "+tl.x+","+tl.y+" - "+br.x+","+br.y+": "+(searching>0));
        if (searching==10||searching==100||searching==1000||searching==10000||searching==100000) {
          println(name+"; try  "+searching+": MISS at "+np.x+","+np.y+" bounds: "+tl.x+","+tl.y+" - "+br.x+","+br.y);
        }
      }
      if (searching==0) return np;
      else return new RPoint(0,0);
  }
  RPoint getcentre() {
   RPoint tl=outline.getTopLeft();
   RPoint br=outline.getBottomRight();
   return new RPoint((tl.x+br.x)/2,(tl.y+br.y)/2);
  }
}

class weightedpixel {
  float bright;
  RPoint pt;
  float index; //index weighted from 0-1
  weightedpixel(RPoint _p,float _b) {
    pt=_p;
    bright=_b;
  }
}

class bitmapcountry extends country {
  //examines a bitmap
  //builds a table of population desnsity
  
  //look at it from the POV of how its gonna be used
  //getpoints(int num) should be able to return an array of points to draw from
  //should be dithered
  //has to distribute the points around the brightest points first
  //distribute in proportion to their brightness - weighted
  
  //table of pixels: if within shape:
  //sample brightness, keep running total and store normalised weighted index for quick searching
  
  float xo,xs,yo,ys;
  Vector<weightedpixel> points = new Vector<weightedpixel>();
  bitmapcountry(){super();}
  bitmapcountry(String n,float c,float m,RShape shp) {
    super(n,c,m,shp);
  }
  void analyse(float _xo,float _xs,float _yo,float _ys) {
      int step=10; //speedup
        xo=_xo;
        xs=_xs;
        yo=_yo;
        ys=_ys;
        //scan country outline by pixel
        RPoint tl=outline.getTopLeft();
        RPoint br=outline.getBottomRight();
        RPoint tlp=normpix(tl);
        RPoint brp=normpix(br);
        float pixstep=xs/lightmap.width;
        float totalbright=0;
        float bmin=255;
        float bmax=0;
        println("searching "+tl.x+","+tl.y+" -> "+(tl.x+(pixstep*(brp.x-tlp.x)))+","+(tl.y+(pixstep*(brp.y-tlp.y))));
        for (int i=0;i<brp.x-tlp.x;i+=step) {
          for (int j=0;j<brp.y-tlp.y;j+=step) {
            RPoint pn=new RPoint(tl.x+(i*pixstep),tl.y+(j*pixstep));
            if(outline.contains(pn)) {
              float bn=brightness(lightmap.get((int)brp.x+i,(int)brp.y+j))+1;//gives a 0.5% weighting to blank pixels
              points.add(new weightedpixel(pn,bn));
              totalbright +=bn;
              if (bn>bmax) bmax=bn;
              if (bn<bmin) bmin=bn;
            }
          }
        }
        float runbright=0;
        float bfactor=1.0/totalbright;
        for (int i=0;i<points.size();i++) {
          runbright+=points.get(i).bright*bfactor;
          points.get(i).index=runbright;
        }
        if (DEBUG) println(name+"; bounds: "+tl.x+","+tl.y+" : "+br.x+","+br.y+" - "+points.size()+" pixels, "+bmin+"-"+bmax+" avg: "+(totalbright/points.size()));
        
  }
  RPoint normalise(RPoint p) {
    float px=(((p.x-xo)/xs)-0.5)*PI*2; //26)/736);
    float py=(((p.y-yo)/ys)-0.5)*PI; //90)/390);
        
    return new RPoint(px,py);
  }
  RPoint normpix(RPoint p) {
    float px=((p.x-xo)/xs)*lightmap.width;
    float py=((p.y-yo)/ys)*lightmap.height;
        
    return new RPoint(px,py);
  }
  RPoint getpoint(){
    float index=random(1.0);
    int i=0;
    while (points.get(i).index<index&&i<points.size()) {
      i++;
    }
    return new RPoint(points.get(i).pt.x+random(1),points.get(i).pt.y+random(1));
  }
}

class calldata {
  Vector<bitmapcountry> countries = new Vector<bitmapcountry>();
  HashMap<String, Integer> outlines = new HashMap<String, Integer>();
  proxml.XMLElement xmlcountries;
  XMLInOut xmlInOut;
  PApplet pApplet;
  boolean loaded; 
  
  country getcountry(int w) {
    return countries.get(w);
  }
  
  void loadxml(proxml.XMLElement element) {
    xmlcountries = element;
    //reconstruct countries from xml data including attaching shapes
    proxml.XMLElement country;
    proxml.XMLElement pt;
    
    int pts=0;
    
    for(int i = 0; i < xmlcountries.countChildren();i++){
      country = xmlcountries.getChild(i);
      String name=country.getAttribute("name");
      if (outlines.containsKey(name.substring(0, 3))) {
        bitmapcountry c=new bitmapcountry(name,(int)country.getFloatAttribute("calls"),(int)country.getFloatAttribute("mins"),shp.children[outlines.get(name.substring(0, 3))]);
        for(int j = 0; j < country.countChildren();j++){
          pt = country.getChild(j);
          weightedpixel p=new weightedpixel(new RPoint(pt.getFloatAttribute("x"),pt.getFloatAttribute("y")),pt.getFloatAttribute("b"));
          p.index=pt.getFloatAttribute("i");
          c.points.add(p);
        }
        pts+=country.countChildren();
        countries.add(c);
      }
    }
    println("loaded "+countries.size()+" countries, "+pts+" data points");
    loaded=true;
  }
 
  calldata(String[][] data,RShape shp,String filename,PApplet _pApplet) {
    boolean parsedata=true;
    pApplet=_pApplet;
    loaded=false;
    
    /*
    try { //to deserialise
      File file = new File("countries.dat");
      ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
      Vector<bitmapcountry> countries = (Vector<bitmapcountry>) in.readObject();
      in.close();
      parsedata=false;
    } catch (ClassNotFoundException e) {
      println("problem parsing countries.dat");
      e.printStackTrace();
    } catch (IOException e) {
      println("problem loading countries.dat");
    } 
    if (parsedata) {  
      
      */ 
      
      for (int i=0;i<shp.children.length;i++) {
        outlines.put(shp.children[i].name.substring(0, 3),i);
      }
      
      xmlInOut = new XMLInOut(pApplet);
      try{
        xmlInOut.loadElement(filename); 
      }catch(Exception e){
        //if the xml file could not be loaded it has to be created
        proxml.XMLElement xmlcountries = new proxml.XMLElement("xmlcountries");

        println("parsing "+data.length+" svg entities");
        //detect number of countries
        int num=0;
        if (outlines.containsKey(data[0][1].substring(0, 3))) {
          countries.add(new bitmapcountry(data[0][1],0.0,0.0,shp.children[outlines.get(data[0][1].substring(0, 3))]));
        }
        for (int i=0; i < data.length; i++) { 
          if (data[i][1].substring(0,3).equals(countries.lastElement().name.substring(0, 3))) {
            countries.lastElement().addnetwork(Float.valueOf(data[i][3].trim()).floatValue(),Float.valueOf(data[i][4].trim()).floatValue());
          }
          else {
            if (outlines.containsKey(data[i][1].substring(0, 3))) {
              countries.add(new bitmapcountry(data[i][1],Float.valueOf(data[i][3].trim()).floatValue(),Float.valueOf(data[i][4].trim()).floatValue(),shp.children[outlines.get(data[i][1].substring(0, 3))]));
            }
          }      
        }
         for (int i=0; i < countries.size(); i++) {  
            //if (DEBUG) countries.get(i).printOut();      
            countries.get(i).analyse(18.279,746.302,129.314,374.293);
            proxml.XMLElement country = new proxml.XMLElement("country");
            country.addAttribute("name",countries.get(i).name);
            country.addAttribute("calls",countries.get(i).calls);
            country.addAttribute("mins",countries.get(i).mins);
            for (int j=0; j < countries.get(i).points.size(); j++) {
              proxml.XMLElement pt = new proxml.XMLElement("pt");
              pt.addAttribute("b",countries.get(i).points.get(j).bright);
              pt.addAttribute("x",countries.get(i).points.get(j).pt.x);
              pt.addAttribute("y",countries.get(i).points.get(j).pt.y);
              pt.addAttribute("i",countries.get(i).points.get(j).index);
              country.addChild(pt);
            }
            xmlcountries.addChild(country);
         }
         xmlInOut.saveElement(xmlcountries,filename);
         loaded=true;
      }
  }
}

void xmlEvent(proxml.XMLElement element){
    //reconstruct countries from xml data including attaching shapes
    calls.loadxml(element);
}