var io = require('socket.io').listen(7231);
io.set('log level', 1);

var LOG = function(text) {
  console.log('('+(new Date).toLocaleTimeString()+') '+text);
}

var FindFreeElement = function(arrayFromFind) {
  for (var i=0; i <= arrayFromFind.length; i++) {  
   if (i == arrayFromFind.length) return i;
   if (arrayFromFind[i] === undefined || arrayFromFind[i] == null) return i;
  }
}

var AddRectElement = function(array, x, y, size, elem) {
  for (var i=0; i<=size-1; i++) {
   for (var j=0; j<=size-1; j++) {
    array[x+i][y+j] = elem;
   }
  }
}

var CheckRect = function(array, x, y, size, elem) {
  for (var i=0; i<size-1; i++) {
   for (var j=0; j<size-1; j++) {
    if (array[x+i][y+j] != elem) return false;
   }
  }
  return true;
}

var FindFreeRect = function(arr, size, elem) {
  var x = Math.round(Math.random()*arr.length-1), y = Math.round(Math.random()*arr[0].length-1);
  while (!CheckRect(arr, x, y, size, elem)) {
   x = Math.round(Math.random()*arr.length-1);
   y = Math.round(Math.random()*arr[0].length-1);
  }
  return [x, y];
}

var mapW = 256, mapH = 256;
var map = [];
for (var x=0; x<mapW-1; x++) {
  map[x] = new Array(mapH);
}
var BLOCK = 1, BLOCK_STEEL = 2, GRASS = 3, WATER = 4;
for (var x=0; x<mapW/2-1; x++)
  for (var y=0; y<mapH/2-1; y++) {
   if (Math.round(Math.random()*3) == 2) {
    var block = Math.round(Math.random()*4);
    AddRectElement(map, x*2, y*2, 2, block);
   } else {
    AddRectElement(map, x*2, y*2, 2, 0);
   }
  }
   
var userList = [];

var publickData = ['id', 'name', 'pos', 'color'];
var GetPublickUserList = function(ignore) {
  var data = []
  for (var i=0; i<userList.length; i++)
   if ((userList[i]) && i!=ignore) {
    data[i] = {};
    for (var j=0; j<publickData.length-1; j++) {
     var key = publickData[j];
     data[i][key] = userList[i][key];
    }
   }
  return data;
}
   
var Player = function(socket, id, name, color, pos) {
  this.socket = socket;
  this.id = id;
  this.name = name;
  this.color = color;
  this.pos = pos;
  this.changePosition = function(x, y) {
   this.pos[0] = x;
   this.pos[1] = y;
  }
  userList[this.id] = this;
  socket.json.send({'evt': 'reAut', 'id': id, 'map': map, 'pos': pos, 'ulist': GetPublickUserList(id)});
  socket.broadcast.json.send({'evt': 'newP', 'id': id, 'pos': pos, 'name': name, 'clr': color});
  LOG('New player, name: '+name+', id: '+id+', position: ['+pos[0]+'; '+pos[1]+']');
  this.socket.playerObject = this;
}
   
LOG('Welcome to "BCW" server!');

io.sockets.on('connection', function (socket) {
  socket.on('disconnect', function() {
   LOG('Player lost, name: '+socket.playerObject.name+', id: '+socket.playerObject.id);
   delete userList[socket.playerObject.id];
  });
   
  socket.on('message', function(data) {
   switch (data.evt) {
    case 'aut':
     new Player(socket, FindFreeElement(userList), data.name, data.clr, FindFreeRect(map, 5, 0));
     break;
   }
  });
});

var log = true;

var LOG = function(data) {
   if (log) console.log(data);
}

var EnableLog  = function() {    
   log = true;
   LOG('Log enabled!');
}

var DisableLog  = function() {    
   LOG('Log disaled!');
   log = false;
}

Number.prototype.degree = function () {
      return this * Math.PI / 180;
}

//Engine inits and settings functions
//----------------------------------------------------------------------
var cnv, ctx;   
var upsCount, fpsCount, ups, fps, lastTick, nowTick, fpsInterval, upsInterval;

var InitRock = function(initCnv, initCtx) {
   cnv = initCnv;
   if (arguments.length == 1) ctx = cnv.getContext('2d');
   else ctx = initCtx;
    onmousemove = function(e) {
    mouseX = e.clientX;
    mouseY = e.clientY;
   }
   onclick = function(e) {
    isclicked = true;
    setTimeout(function() {
     isclicked = false;
    }, 1000/ups);
   }
   document.onkeydown = function(e) {
    keysPresseds[e.keyCode] = true;
    setTimeout(function() { keysUnpresseds[e.keyCode] = false; }, 1000/ups);
   }
   setInterval(function() {
    ups = upsCount;
    upsCount = 0;
    fps = fpsCount;
    fpsCount = 0;
   }, 1000);
   LOG('Rock init succesfull! Screen width: '+cnv.width+'px, screen height: '+cnv.height+'px;');
}

var ShowCursor = function(bool) {
   if (bool == true) cnv.style.cursor = 'main';
   if (bool == false) cnv.style.cursor = 'none';
}

var GetFPS = function() {
   return fps;
}

var GetUPS = function() {
   return ups;
}

var RegRenderFunction = function(func) {
   var RenderFunction = function() {
    func();
    fpsCount++;
    setTimeout(function() {
     RenderFunction();
    }, 4);
   }
   RenderFunction();
   LOG('Render function registrated!');
}

var RegStepFunction = function(func, ups) {
   upsInterval = 1000/ups;
   lastTick =  new Date();
   setInterval(function() {
    nowTick = new Date();
    deltaTime = (nowTick.getTime() - lastTick.getTime())/upsInterval;
    lastTick = nowTick;
    upsCount++;
    func(deltaTime);
   }, upsInterval);
   LOG('Step function registrated!');
}

//Load functions
//----------------------------------------------------------------------
var imgs = {};
var LoadTextures = function(loadList, path, onchank, onload) {
   var all_sprites = 0, sprites_loaded = 0;
   for (var i in loadList) all_sprites++;
   for (var key in loadList) {
    name = key;  imgs[key] = new Image();
    imgs[key].src = path+loadList[key];
    imgs[key].name = key;
    imgs[key].onload = function() {
     LOG('Texture "'+this.name+'" loaded with "'+path+loadList[this.name]+'";');
     sprites_loaded++;
     if (sprites_loaded == all_sprites) {   
      onload();   
     } else {
      onchank(Math.round(sprites_loaded/all_sprites*100));
     }
    }
   }    
}

//Tiles
var Tile = function(texname, repeat) {
   var ptrn = ctx.createPattern(imgs[texname], repeat);    
   return ptrn;
}

var DrawTiles = function(tile, x, y, w, h) {
   ctx.save();
   ctx.translate(x, y);
   ctx.fillStyle = tile;
   ctx.fillRect(0, 0, w, h);
   ctx.restore();
}

//Textures workers
//----------------------------------------------------------------------
var DrawTexture = function(tex_name, x, y, offsetX, offsetY, angle, alpha, partX, partY, partW, partH) {
   if (arguments.length > 3) {
    ctx.save();   
    ctx.translate(Math.floor(x), Math.floor(y));
    if (angle > 360) {
     var fullAngles = Math.floor(angle/360);
     angle -= fullAngles*360;
    }
    ctx.rotate((angle).degree());   
    if (arguments.length > 6) ctx.globalAlpha = alpha;
    if (arguments.length > 7) {
     ctx.drawImage(imgs[tex_name], partX, partY, partW, partH, -offsetX, -offsetY, partW, partH)
    } else ctx.drawImage(imgs[tex_name], -offsetX, -offsetY);
    ctx.restore();   
   } else ctx.drawImage(imgs[tex_name], x, y);
}

//Sprite engine
//----------------------------------------------------------------------
var SpriteObj = {
   texName: '',   
   animList: {},
   currentAnim: '',
   currentFrame: 0,   
   frameWidth: 0,   
   frameHeight: 0,   
   offsetX:0,   
   offsetY:0,   
   animSpeed:0,
   timerForNextFrame: false
}

var DrawSprite = function(spr, x, y, angle, alpha) {
   if    (spr.timerForNextFrame == false) {
    spr.timerForNextFrame = true;
    var pointSprite = spr;
    setTimeout(function() {
     pointSprite.timerForNextFrame = false;
     if (pointSprite.currentFrame == pointSprite.animList[pointSprite.currentAnim].lastFrame) {
      pointSprite.currentFrame = pointSprite.animList[pointSprite.currentAnim].firstFrame;
      } else {
       pointSprite.currentFrame++;   
      }
    }, 1000/pointSprite.animSpeed);
   }
   DrawTexture(spr.texName, x, y, spr.offsetX, spr.offsetY, angle, alpha,  spr.currentFrame*spr.frameWidth, 0,
    spr.frameWidth, spr.frameHeight)   
}

var SpriteSetAnim = function(spr, name) {
   spr.currentAnim = name;
   spr.currentFrame = spr.animList[name].firstFrame;
}

var Sprite = function(textureName, frms, frmW, frmH, offsX, offsY, animL, animSpd) {
   var newSprite = {__proto__: SpriteObj};
   with (newSprite) {
    texName = textureName;
    frames = frms;
    frameWidth = frmW;
    frameHeight = frmH;
    animSpeed = animSpd;
    offsetX = offsX;
    offsetY = offsY;
    for (var key in animL) {
     animList[key] = {};
     animList[key].firstFrame = animL[key][0];
     animList[key].lastFrame = animL[key][1];
    }
   }   
   LOG('Sprite created, he object: ');
   LOG(newSprite);
   return newSprite;
}

//Primitivs draw functions
//----------------------------------------------------------------------
var textColor = '#000000';

var SetTextColor = function(color) {
   textColor = color;
}

var SetTextFont = function(font) {
   ctx.font = font;
}

var SetTextAlign = function(align) {
   ctx.textAlign = align;
}

var DrawText = function(text, x, y) {
   ctx.fillStyle = textColor;
   ctx.fillText(text, x, y);
}

var ClearScreen = function(color) {
   ctx.save();
   ctx.fillStyle = color;
   ctx.fillRect(0, 0, cnv.width, cnv.height);
   ctx.restore();
}

//Input controls functions
//----------------------------------------------------------------------
var mouseX, mouseY, isclicked;
var keysPresseds = [], keysUnpresseds = [];

var GetMouseX = function() {
   return Math.round(mouseX);
}

var GetMouseY = function() {
   return Math.round(mouseY);
}

var MouseClicked = function() {
   if (isclicked == true) {
    isclicked = false;
    return true;
   }   
   else
    return false;
}

var KeyPressed = function(key) {
   if (keysPresseds[key] == true) {
    keysPresseds[key] = false;
    return true;
   }
   else   
    return false;
}

window.onload = function() {
  InitRock(document.getElementById('canvas'));
   
  ShowCursor(false);
   
  ClearScreen('#804000');
  SetTextColor('#80FFFF');
  SetTextFont('32px TimesNewRoman');
  SetTextAlign('center');
  DrawText('Загрузка графики... 0%', 400, 250);
   
  var Start = function() {
   with(this){
    sprCursor = new Sprite('texCursor', 2, 24, 24, 12, 12, {'main':[0, 1]}, 1);
    SpriteSetAnim(sprCursor, 'main');
    tileGrass = new Tile('texGrass', 'repeat');
   }
   
   RegStepFunction(Update, 30);
   RegRenderFunction(Render);
    
   SetTextColor('#80FFFF');
   SetTextFont('16px TimesNewRoman');
   SetTextAlign('left');
    
  }  
   
  var Update = function(dt) {
   if (MouseClicked()) alert('click!');
   if (KeyPressed(90)) alert('Z pressed!');
  }
   
  var Render = function() {
   ClearScreen('#0080C0');
   DrawText('fps: '+GetFPS()+'; ups: '+GetUPS(), 5, 15);
   DrawTiles(tileGrass, 0, 552, 800, 48);
   DrawSprite(sprCursor, GetMouseX(), GetMouseY(), 0, 1);
  }
   
  LoadTextures({'texCursor':'сursor.png', 'texGrass':'grass.png'}, 'res/',  
  function(procent){
   ClearScreen('#82CFFD');
   DrawText('Загрузка графики... '+procent+'%', 400, 250);
  }, Start);
}