local Battler = require("scenes.battlesystem.actors.battler")
local Hero = Battler:extend()

local gui         = require "game.modules.gui"

-- INIT FUNCTIONS
-- Initialize the hero

function Hero:new(world, x, y, charid, charnumber)
  Hero.super.new(self, world, x, y, 0)
  self.isHero     = true
  self.turnAction = nil
  self.startx, self.starty = self.x, self.y
  self.dx, self.dy = self.x, self.y
  self.direction = 1
  self.directionPrevious = 1

  if charid == nil then
    core.debug:error("FATAL ERROR: charid not set")
  end
  self.charid     = charid
  self.charnumber = charnumber or 1

  self.hp = game.characters.list[self.charid].stats.hp
  self.pp = game.characters.list[self.charid].stats.pp


  self.actionPerTurn = game.characters.list[self.charid].turns

  self:initSprite()
  self:initChoregraphySystem()

  self:initVoices()
end

-- ASSETS FUNCTIONS
-- Load and play assets needed by the character

function Hero:initVoices()
  self:addVoiceEffect("move")
  self:addVoiceEffect("turnstart")
end

function Hero:addVoiceEffect(name)
  local completename = self.charid .. "_" .. name
  local path = "datas/gamedata/characters/" .. self.charid .. "/voices/" .. name .. ".wav"
  self.assets:newSFX(completename, path)
end

function Hero:talk(name)
  local completename = self.charid .. "_" .. name
  self.assets.sfx[completename]:play()
end

-- INFO FUNCTIONS
-- All functions to get information from the character

function Hero:getStats()
  return game.characters.list[self.charid].stats
end

-- STATS FUNCTIONS
-- All functions related to stats

function Hero:setHP(value, relative)
  if relative == true then
    value = game.characters.list[self.charid].stats.hp + value
  end

  game.characters.list[self.charid].stats.hp = value
  self.tweens:newTween(0, 0.3, {hp = game.characters.list[self.charid].stats.hp}, 'linear')
end

function Hero:setPP(value, relative)
  if relative == true then
    value = game.characters.list[self.charid].stats.pp + value
  end

  game.characters.list[self.charid].stats.pp = value
  self.tweens:newTween(0, 0.3, {pp = game.characters.list[self.charid].stats.pp}, 'linear')
end


-- ACTIVITY FUNCTION
-- Function to set or unset activity to the character

function Hero:setActive()
  core.debug:print("cbs/hero", "hero " .. self.charid .. " is now active")
  local gridsize = game.characters.list[self.charid].move
  if (gridsize == nil) then
    gridsize = 3
    core.debug:warning("cbs/character", "move value is nil")
  end
  self.world.cursor:setGrid(self.x, self.y, "circle", gridsize, 1, self)
  self.startx, self.starty = self.x, self.y
  self.world.cursor:set(self.startx, self.starty)
  self.currentAction = "selectDirection"

  self:talk("turnstart")

  self.directionPrevious = self.direction
end

-- UPDATE FUNCTION
-- Update the hero

function Hero:update(dt)
  Hero.super.update(self, dt)

  self.keys = self.scene:getKeys(1)

  if (self.isChoregraphyActive) then
    self:updateChoregraphy()
  end

  if (self.currentAction == "moving") then
    self:updateMoving(dt)
  elseif (self.currentAction == "selectAttack") then
    self:updateActionSelection(dt)
  elseif (self.currentAction == "selectDirection") then
    self:updateDirectionSelection(dt)
  end
end

function Hero:updateMoving(dt)
  -- Store previous position, in order to be able to go back here more easily
  -- when needed
  self.xprevious = self.x
  self.yprevious = self.y

  -- Move the player toward its destination
  self.x = (self.x) + ((self.dx) - (self.x)) * dt*10
  self.y = (self.y) + ((self.dy) - (self.y)) * dt*10

  -- Calculate speed to calculate animation speed
  local xspeed, yspeed  = math.abs(self.x - self.xprevious),
                          math.abs(self.y - self.yprevious)

  local speed = math.sqrt(xspeed*xspeed + yspeed*yspeed) * 32
  self:setCustomSpeed(speed * 10)

  -- Handle direction
  local direction = utils.math.sign(self.x - self.xprevious)
  if direction ~= 0 then
    self.direction = direction
  end

  -- If the hero is near enough its final destination, switch to
  -- action selection
  if (math.abs(self.x - self.dx) < 0.01) and (math.abs(self.y - self.dy) < 0.01) then
    self.x = self.dx
    self.y = self.dy
    self:changeAnimation("idle")
    self.currentAction = "selectAttack"
    self.world:resetActiveGrid()
    self.scene.menu:set( self )
  end
end

function Hero:updateActionSelection(dt)
  -- Change direction by pressing left or right when selecting the next action
  if (self.keys["left"].isPressed) then
    self.direction = -1
  elseif (self.keys["right"].isPressed) then
    self.direction = 1
  end
end

function Hero:updateDirectionSelection(dt)
  self.xprevious = self.x
  self.yprevious = self.y

  self.x = (self.x) + ((self.startx) - (self.x)) * dt*10
  self.y = (self.y) + ((self.starty) - (self.y)) * dt*10

  local xspeed, yspeed  = math.abs(self.x - self.xprevious),
                          math.abs(self.y - self.yprevious)

  local speed = math.sqrt(xspeed*xspeed + yspeed*yspeed) * 32
  self:setCustomSpeed(speed * 10)
  local direction = utils.math.sign(self.x - self.xprevious)
  if direction ~= 0 then
    self.direction = direction
  end

  if (math.abs(self.x - self.startx) < 0.01) and (math.abs(self.y - self.starty) < 0.01) then
    self.x = self.startx
    self.y = self.starty
    self:changeAnimation("idle")
    self.direction = self.directionPrevious
  end
end

-- SIGNAL FUNCTIONS
-- All functions related to signal receiving

function Hero:receiveSignal(action_type, id)
  if id == nil then
    core.debug:print("battler/hero", "action selected : " .. action_type)
  else
    core.debug:print("battler/hero", "action selected : " .. action_type .. " (" .. id .. ")")
  end
  if (action_type == "defend") then
    self.turnAction = "defend"
    self:switchActiveBattler( )
  elseif (action_type == "attack") then
    --self:changeAnimation("hit1")
    self:attack()
  elseif (action_type == "skill") then
    self:useSkill(id)
  else
    self:switchActiveBattler( )
  end
end

function Hero:receiveBackSignal()
  self.currentAction = "selectDirection"
  self.world.cursor:set(self.x, self.y)

  self:changeAnimation("walk")
end

function Hero:timerResponse(timer)
  if timer == "switchActiveBattler" then
    self.world:switchActiveBattler()
  elseif timer == "wait" then
    self.choregraphy.changeAction = true
  end
end

-- ACTION FUNCTIONS
-- All functions related to actions

function Hero:validateAction()
  if (self.currentAction == "selectDirection") then
    self:changeAnimation("walk", true)
    self.currentAction = "moving"
    self.dx, self.dy = self.world.cursor.x, self.world.cursor.y

    --self:talk("move")

    self.world.cursor:unset( )
  end
end

function Hero:switchActiveBattler()
  self.tweens:newTimer(0.15, "switchActiveBattler")
end

-- CHOREGRAPHY FUNCTIONS
-- All functions related to the choregraphy system

function Hero:initChoregraphySystem()
  self.choregraphy = {}
  self.choregraphy.current      = 0
  self.choregraphy.isFinished   = false
  self.choregraphy.changeAction = true
  self.choregraphy.data = {}
  self.choregraphy.effectArea   = nil
  self.choregraphy.dx           = self.x
  self.choregraphy.dy           = self.y
  self.choregraphy.blockedBy    = ""

  self.isChoregraphyActive      = false
end

function Hero:attack(id, dx, dy)
  local skill = game.skills:getSkillData("attack")
  self:startChoregraphy(skill, dx, dy)
end

function Hero:useSkill(id, dx, dy)
  local skill = game.skills:getSkillData(id)
  self:setPP(skill.cost * -1, true)
  self:startChoregraphy(skill, dx, dy)
end

function Hero:startChoregraphy(skill, dx, dy)
  local skill = skill
  self.choregraphy.current      = 0
  self.choregraphy.isFinished   = false
  self.choregraphy.changeAction = true
  self.choregraphy.data         = skill.choregraphy
  self.choregraphy.effectArea   = skill.effectArea
  self.choregraphy.dx           = dx or self.x
  self.choregraphy.dy           = dy or self.y

  self.choregraphy.haveSentDamage = false

  self.isChoregraphyActive      = true
end

function Hero:updateChoregraphy(dt)
  if (self.choregraphy.changeAction) then
    self:switchAction()
  end
end

function Hero:switchAction()
  self.choregraphy.current = self.choregraphy.current + 1
  local nextAction = self.choregraphy.data[self.choregraphy.current]
  if nextAction == nil then
    self.isChoregraphyActive = false
    self:switchActiveBattler()
  else
    local condition = nextAction[2]
    if (condition == "sentDamage") and (not self.choregraphy.haveSentDamage) then
      core.debug:print("cbs/hero", "you didn't do damage, skipping " .. nextAction[1])
      self:switchAction()
    else
      self:doChoregraphyAction(nextAction)
    end

  end
end

function Hero:doChoregraphyAction(choregraphyAction)
  local type = choregraphyAction[1] or "unknown"
  self.choregraphy.changeAction = true

  if type == "wait" then
    local duration = choregraphyAction[3] or 1
    self:wait(duration)
  elseif type == "setAnimation" then
    local animation     = choregraphyAction[3]
    local blockProcess  = choregraphyAction[4]
    self:changeAnimation(animation)
    if (blockProcess) then
      self.choregraphy.blockedBy    = animation
      self.choregraphy.changeAction = false
    end
  elseif type == "sendDamage" then
    local xx = self.x + self.direction
    local yy = self.y
    local power     = choregraphyAction[3]
    local accuracy  = choregraphyAction[4]
    local isSpecial = choregraphyAction[5]
    local isAerial  = choregraphyAction[6]
    self.choregraphy.haveSentDamage = self:sendDamage(xx, yy, power, accuracy, isSpecial, isAerial)
  elseif type == "addGFX" then
    local sprite    = choregraphyAction[3]
    local dx        = choregraphyAction[4]
    local dy        = choregraphyAction[5]
    local affectedByDirection = choregraphyAction[6]
    if (affectedByDirection) then
      dx = dx * self.direction
    end
    local blockProcess = choregraphyAction[7]

    local x         = self.x
    local y         = self.y
    local z         = 0

    self.world.obj.GFX(self.world, x + dx, y + dy, z, sprite, self, blockProcess)
  elseif type == "playSFX" then
    local sfx = choregraphyAction[3]
    self.assets.sfx[sfx]:play()
  else
    core.debug:warning("cbs/hero", "unknown action type " .. type)
  end
end

function Hero:wait(time)
  self.tweens:newTimer(time, "wait")
  self.choregraphy.changeAction = false
end

-- SPRITE FUNCTIONS
-- Handle the hero sprite

function Hero:initSprite()
  self.assets:addSprite(self.charid, "datas/gamedata/characters/" .. self.charid .. "/sprites")
  self.assets.sprites[self.charid]:setCustomSpeed(16)
  self:setSprite(self.charid, 32, 48, true)
  self:cloneSprite()
  self:changeAnimation("idle")
end

function Hero:animationEnded(animation)
  if (animation == self.choregraphy.blockedBy) then
    self.choregraphy.blockedBy    = ""
    self.choregraphy.changeAction = true
  end
end

-- STATS FUNCTIONS
-- Handle character stats and stuff

function Hero:setHP(value, relative)
  if (relative) then
    local hp = game.characters.list[self.charid].stats.hp
    value = hp + value
  end

  game.characters.list[self.charid].stats.hp = value
end

-- DRAW FUNCTIONS
-- Draw everything related to the hero

function Hero:draw()
  x, y = self.maputils.gridToPixel(self.x, self.y, true)
  --love.graphics.rectangle("fill", x - 8, y - 32, 16, 32)
  self:drawSprite()
end

function Hero:drawIcon(x, y)
  local iconID = 1
  self.assets.tileset["charicons"]:drawTile(iconID, x, y)
end

function Hero:drawHUD()
  local HUDBASE = 8
  local HUDSEP  = 152
  local x = HUDBASE + (self.charnumber-1)*HUDSEP
  local y = self.world:getPlayerHUDPosition()

  self.assets.images["e_speedster"]:draw(x, y)
  core.screen:setScissor(x, y-16, 32, 40)
  self.assets.sprites[self.charid]:drawAnimation(x+14, y+14)
  core.screen:resetScissor( )
  self.assets.images["m_speedster"]:draw(x, y)
  self.assets.images["statusbar"]:draw(x+12, y-6)

  local hpmax = game.characters.list[self.charid].stats.hpmax
  local ppmax = game.characters.list[self.charid].stats.ppmax

  local bar1 = math.floor((self.hp/hpmax)*107)
  local bar2 = math.floor((self.pp/ppmax)*108)

  love.graphics.setColor(248/255, 160/255, 0, 1)
  gui.drawBar(x+29, y+5, bar1, 7)
  love.graphics.setColor(0, 248/255, 248/255, 1)
  gui.drawBar(x+17, y+17, bar2, 7)
  utils.graphics.resetColor()

  self.assets.fonts["hudnbrs_small"]:set()
  love.graphics.print(math.floor(self.hp) .. "/" .. hpmax, x+34, y+5)
  love.graphics.print(math.floor(self.pp) .. "/" .. ppmax, x+28, y+17)

  local lvl = game.characters.list[self.charid].stats.level

  if lvl < 100 then
    lvl = "0" .. lvl
  end

  love.graphics.print(lvl, x+122, y-5)
end

return Hero