print("*** LOADING MAP.nas ... ***");
var zoom  = 10;
var width = 768;
var height = 576;

#------------------------------------------------------------------------------- thanks to Harbal1
#===============================================================================
#                                                                      FUNCTIONS

#-------------------------------------------------------------------------------
#                                                                       draw_arc
# this function draws an arc
# params :
# - element     : canvas object created by createChild()
# - center_x    : coord x of the center of the arc in px
# - center_y    : coord y of the center of the arc in px
# - radius      : radius
# - start_angle : start angle in deg ()
# - end_angle   : end angle in deg ()
# - color       : color
# - line_width  : line_width
#
var draw_arc = func(element, center_x, center_y, radius, start_angle, end_angle, color, line_width)
{
  var coord_start_x = center_x + (radius * math.cos(start_angle * D2R));
  var coord_start_y = center_y - (radius * math.sin(start_angle * D2R));

  var to_x = -(radius * math.cos(start_angle * D2R)) + (radius * math.cos(end_angle * D2R));
  var to_y = (radius * math.sin(start_angle * D2R)) - (radius * math.sin(end_angle * D2R));

  element.setStrokeLineWidth(line_width)
    .set("stroke", color)
    .moveTo(coord_start_x, coord_start_y)
    .arcSmallCCW(radius, radius, 0, to_x, to_y);

  print("coord_start_x:"~coord_start_x~"| coord_start_y:"~coord_start_y~"| radius:"~ radius ~"| to_x:"~to_x~"| to_y:"~ to_y);
}

#-------------------------------------------------------------------------------
#                                                                     draw_piste
# this function creates a piste
#
# params :
# - element  : canvas object created by createChild()
#
var draw_piste = func(element)
{
  element.setStrokeLineWidth(5)
    .set("stroke", "rgba(40, 240, 40, 1)")
    .moveTo(-13, 13)
    .lineTo(-13, -13)
    .moveTo(13, 13)
    .lineTo(13, -13);

  # creation du vecteur vitesse+cap de la cible
  element.setStrokeLineWidth(4)
    .set("stroke", "rgba(40, 240, 40, 1)")
    .moveTo(0, 0)
    .lineTo(0, 0);

  element.setStrokeLineWidth(4)
    .set("stroke", "rgba(40, 240, 40, 1)")
    .moveTo(-12, 11)
    .lineTo(12, 11)
    .moveTo(-12, -11)
    .lineTo(12, -11);
}

#-------------------------------------------------------------------------------
#                                                                   update_piste
# this function updates piste - length of vector = distance in 15s
#
# params :
# - element  : canvas object created by createChild()
# - FIXME ...
#
var update_piste = func(element, my_heading, my_alt, target_heading, target_alt, target_speed, pixel_range, radar_range)
{
  var vector_x = ((target_speed * pixel_range / radar_range) / 240) * math.sin((target_heading - my_heading) * D2R);
  var vector_y = ((target_speed * pixel_range / radar_range) / 240) * math.cos((target_heading - my_heading) * D2R);
  if((target_alt - 1000 ) < my_alt) {
    element._node.getNode("coord[12]", 1).setValue(-12);
  } else {
    element._node.getNode("coord[12]", 1).setValue(12);
  }
  if((target_alt + 1000 ) > my_alt) {
    element._node.getNode("coord[16]", 1).setValue(-12);
  } else {
    element._node.getNode("coord[16]", 1).setValue(12);
  }
  element._node.getNode("coord[8]", 1).setValue(vector_x);
  element._node.getNode("coord[9]", 1).setValue(-vector_y);
}

#-------------------------------------------------------------------------------
#                                                                update_piste_fl
# this function updates flight level piste label position
#
# params :
# - element  : canvas object created by createChild()
# - FIXME ...
#
var update_piste_fl = func(element, my_heading, target_heading)
{
  var vector_x = -30 * math.sin((target_heading - my_heading) * D2R);
  var vector_y =  30 * math.cos((target_heading - my_heading) * D2R);

  element.setTranslation(vector_x, vector_y);
}

var MAPCanvas = {
  canvas_settings: {
    "name": "PFD-Test",       # The name is optional but allow for easier identification
    "size": [1024, 1024],     # Size of the underlying texture (should be a power of 2, required) [Resolution]
    "view": [width, height],  # Virtual resolution (Defines the coordinate system of the canvas [Dimensions]
                                # which will be stretched the size of the texture, required)
    "mipmapping": 1           # Enable mipmapping (optional)
  },
  new: func(placement) {
    var m = {
      parents: [MAPCanvas],
      canvas: canvas.new(MAPCanvas.canvas_settings)
    };
    ## Base for the canvas
    m.canvas.addPlacement(placement);
    m.root = m.canvas.createGroup();
    m.mapStuff = m.root.createChild("group");
    m.radarStuff = m.root.createChild("group"); #Should be replaced by rwr

    #MAP stuff
    m.g_front = m.mapStuff.createChild("group");
    m.g_back = m.mapStuff.createChild("group");

    #Aircraft orientation/position stuff
    m.myHeadingProp = props.globals.getNode("orientation/heading-deg");
    m.myCoord = geo.aircraft_position();

    #Center of the canvas
    m.root.setCenter(384,256);

    ##MAP stuff : Set up of the tiles
    m.tile_size = 256;
    m.num_tiles = [4, 3];

    m.type = "map";
    m.home =  props.globals.getNode("/sim/fg-home");
    m.maps_base = m.home.getValue() ~ '/cache/maps';

    #----------------  Make the url where to take the tiles ------------
    #Some alternative can exist
    # http://otile1.mqcdn.com/tiles/1.0.0/map
    # http://otile1.mqcdn.com/tiles/1.0.0/sat
    # (also see http://wiki.openstreetmap.org/wiki/Tile_usage_policy)

    #var makeUrl  = string.compileTemplate('http://{server}.mqcdn.com/tiles/1.0.0/sat/{z}/{x}/{y}.jpg');
    #var servers = ["otile1", "otile2", "otile3", "otile4"];

    m.makeUrl  = string.compileTemplate('http://{server}.tile.osm.org/{z}/{x}/{y}.png');
    m.servers = ["a", "b", "c"];
    m.makePath = string.compileTemplate(m.maps_base ~ '/osm-{type}/{z}/{x}/{y}.png');

    #Setting up red little aircraft
    m.center_tile_offset = [
      (m.num_tiles[0] - 1) / 2,
      (m.num_tiles[1] - 1) / 2
    ];
    # simple aircraft icon at current position/center of the map
    m.filename = "Nasal/littleaircraftRed.svg";
    m.svg_symbol = m.root.createChild("group");
    canvas.parsesvg(m.svg_symbol, m.filename);
    m.svg_symbol.setScale(0.05);

    m.svg_symbol.setTranslation((width/2)-20,height/2-45);

    m.myVector = m.svg_symbol.getBoundingBox();
    #svg_symbol.setCenter(width/2,height/2);
    m.svg_symbol.updateCenter();
    m.svg_symbol.set("z-index", 1);

    var make_tiles = func (canvas_group) {
      var tiles = setsize([], m.num_tiles[0]);
      for (var x = 0; x < m.num_tiles[0]; x += 1) {
        tiles[x] = setsize([], m.num_tiles[1]);
        for (var y = 0; y < m.num_tiles[1]; y += 1) {
          tiles[x][y] = canvas_group.createChild("image", "map-tile");
        }
      }
      return tiles;
    }

    #MAP Stuff
    m.tiles_front = make_tiles(m.g_front);
    m.tiles_back  = make_tiles(m.g_back);

    m.use_front = 1;

    m.last_tile = [-1,-1];
    m.last_type = m.type;

    ##ETC all needed for MAP and RWR canvas
    m.zoom = 10;
    m.update_timer = nil;

    ## RADAR STUFF ##
    m.MapToggle = 1;

    ## creation des arcs "range"
    #m.arc_range1 = m.radarStuff.createChild("path", "arc_range1");
    ##m.arc_range1.moveTo(334,256).arcSmallCCW(50, 50, 0,  434, 256);
    #m.arc_range1.setStrokeLineWidth(3)
    #.moveTo(484, 256)
    #.set("stroke", "rgba(100, 100, 100, 1)")
    #.arcSmallCCW(100, 100, 0, -200, 0)
    #.arcSmallCCW(100, 100, 0, 200, 0);

    # draw_arc(m.arc_range1, 384,256 , 100 , 0, 180, "rgba(100, 100, 100, 1)", 3);

    return m;
  },

  changeZoomMap: func(d) {
    new_zoom = math.max(2, math.min(15, me.zoom + d));
    if (new_zoom != me.zoom) {
      me.zoom = new_zoom;
      #debug.dump(zoom);
      #updateTiles();
    }
  },

  updateTiles: func() {
    #print("updateTiles is working");
    me.svg_symbol.setRotation(me.myHeadingProp.getValue()*D2R);
    #g.setRotation(myHeadingProp.getValue()*D2R);
    me.myCoord = geo.aircraft_position();
    lat = me.myCoord.lat();
    lon = me.myCoord.lon();

    var n = math.pow(2, me.zoom);
    var offset = [
      n * ((lon + 180) / 360) - me.center_tile_offset[0],
      (1 - math.ln(math.tan(lat * math.pi/180) + 1 / math.cos(lat * math.pi/180)) / math.pi) / 2 * n - me.center_tile_offset[1]
    ];
    var tile_index = [int(offset[0]), int(offset[1])];

    var ox = tile_index[0] - offset[0];
    var oy = tile_index[1] - offset[1];
    me.g_front.setVisible(me.use_front);
    me.g_back.setVisible(!me.use_front);

    me.use_front = math.mod(me.use_front + 1, 2);

    for (var x = 0; x < me.num_tiles[0]; x += 1) {
      for (var y = 0; y < me.num_tiles[1]; y += 1) {
        if (me.use_front) {
          me.tiles_back[x][y].setTranslation(int((ox + x) * me.tile_size + 0.5), int((oy + y) * me.tile_size + 0.5));
          #debug.dump("updating back");
        } else {
          me.tiles_front[x][y].setTranslation(int((ox + x) * me.tile_size + 0.5), int((oy + y) * me.tile_size + 0.5));
          #debug.dump("updating front");
        }
      }
    }

    if (tile_index[0] != me.last_tile[0] or tile_index[1] != me.last_tile[1] or me.type != me.last_type) {
      for (var x = 0; x < me.num_tiles[0]; x += 1) {
        for (var y = 0; y < me.num_tiles[1]; y += 1) {
          var server_index = math.round(rand() * (size(me.servers) - 1));
          var server_name = me.servers[server_index];
          var pos = {
            z: me.zoom,
            x: int(offset[0] + x),
            y: int(offset[1] + y),
            type: me.type,
            server: server_name
          };

          (func {
            var img_path = me.makePath(pos);

            if (io.stat(img_path) == nil) {
              var img_url = me.makeUrl(pos);
              var message = "Requesting %s...";
              #printf(message, img_url);
              http.save(img_url, img_path)
              .done(func {
                var message = "Received image %s";
                #printf(message, img_path);
                # if (pos.z == zoom) {
                #   tile.setFile(img_path);
                # }
              })
              .fail(func (r) {
                var message = "Failed to get image %s %s: %s";
                #printf(message, img_path, r.status, r.reason);
                me.tiles_back[x-1][y-1].setFile("");
                me.tiles_front[x-1][y-1].setFile("");
              });
            } else {
              if (pos.z == me.zoom) {
                var message = "Loading %s";
                #printf(message, img_path);
                me.tiles_back[x][y].setFile(img_path);
                me.tiles_front[x][y].setFile(img_path);
              }
            }
          })();
        }
      }

      me.last_tile = tile_index;
      me.last_type = me.type;
    }
  },
  updateRadar:func() {
    #Rotating aircraft to the front.
    me.svg_symbol.setRotation(0*D2R);
  },

  changeMfD_Displaying:func() {

    #Temporary function : we change the displaying called : mirage2000.changeMfD_Displaying()
    if(me.MapToggle) {
      me.mapStuff.hide();
      me.radarStuff.show();
      me.MapToggle = 0;
    } else {
      me.mapStuff.show();
      me.radarStuff.hide();
      me.MapToggle = 1;
    }

  },

  update: func() {
    #Whatever need to be updated
    var update_timer = maketimer(0, func(){
      #print("Hello World");
      if(me.MapToggle) {
        me.updateTiles();
      } else {
        me.updateRadar()
      }
    });
    update_timer.start();

  },
  #Other function like zoom in/out changing tile index, etc
};

var MapCanvas = MAPCanvas.new({"node": "canvasCadre", "texture": "canvasTex.png"});

MapCanvas.update();
