##########################
#    Kyu TextLog V3.0    #
########CONSTANTS########
PADY = 25 #Márgenes en el eje Y
PADX = 25 #Márgenes en el eje X
INTERPAD = 12 #Distancia entre cuadros de texto.
IMG = nil #Imagen de fondo. Dejar en nil si no se quiere ninguna. Si se usa: "nombreImagen".
DEFAULTCOLOR = "<c3=f8f8f8,0f0f0f>" #Color por defecto que se mostrará en el log
##########################

if defined?(PluginManager)
  PluginManager.register({
    :name => "Kyu´s Textlog",
    :version => "3.0",
    :credits => "Kyu"
  })
end

class Log
  def initialize()
    $PokemonGlobal.log ||= [] if !$PokemonGlobal.log
    @pos = $PokemonGlobal.log.length-1
    @viewport = Viewport.new(0,0,Graphics.width,Graphics.height)
    @viewport.z = 99999
    @sprite = Sprite.new(@viewport)

    #Background.
    if !IMG
      @sprite.bitmap = Bitmap.new(Graphics.width,Graphics.height)
      @sprite.bitmap.fill_rect(0,0,Graphics.width,Graphics.height,Color.new(0,0,0))
      @sprite.opacity = 150
    else
      @sprite.bitmap = Bitmap.new("Graphics/Pictures/"+IMG)
    end

    #Text are drawn over this.
    @sprite2 = Sprite.new(@viewport)
    @sprite2.y = PADY
    @sprite2.bitmap = Bitmap.new(Graphics.width,Graphics.height)
    @canvas = @sprite2.bitmap
    pbSetSystemFont(@canvas)
    @totalheight = 0

    @w = 0
    @lines = 0 #Lines currently drawn. Used to know how much @pos
    #will increase when pressing up.

    #Calculates how many texts can be displayed. This are added to
    #an array and then drawn.
    drawLines()

    self.update
  end

  def drawLines(down=false)
    if !down
      aux=[]
      while @totalheight <= Graphics.height - 2*PADY and @pos-@w >= 0
        @totalheight+= 32*$PokemonGlobal.log[@pos-@w].length + INTERPAD
        if @totalheight <= Graphics.height - 2*PADY
          aux.push($PokemonGlobal.log[@pos-@w])
        end
        @w+=1
      end
      @totalheight = 0
      for i in 0...aux.length
        for z in 0...aux[aux.length-1-i].length
          chr = getFormattedText(@canvas,PADX,@totalheight+(32*z),
                Graphics.width - 2*PADX,Graphics.height,
                aux[aux.length-1-i][z],32)
          drawFormattedChars(@canvas,chr)
        end
        @totalheight += 32*aux[aux.length-1-i].length + INTERPAD
      end
      @lines = aux.length
      @pos+=1
      aux.clear
    else #When pressing down
      while @totalheight <= Graphics.height - 2*PADY and (@pos+@w) <= $PokemonGlobal.log.length - 1
        if @totalheight + 32*$PokemonGlobal.log[@pos + @w].length <= Graphics.height - 2*PADY
          for i in 0...$PokemonGlobal.log[@pos + @w].length
            chr = getFormattedText(@canvas,PADX,@totalheight+(32*i),
                  Graphics.width - 2*PADX, Graphics.height,
                  $PokemonGlobal.log[@pos + @w][i],32)
            drawFormattedChars(@canvas,chr)
          end
        end
        @totalheight += 32*$PokemonGlobal.log[@pos + @w].length + INTERPAD
        @w += 1
      end
      @pos+= @w-1
      @lines = @w-1
    end
  end

  def update
    loop do
      if Input.trigger?(Input::DOWN) and @pos < $PokemonGlobal.log.length - 1
        @canvas.clear
        @totalheight = 0
        @w = 0
        #Dibuja cuadros de texto hasta que el siguiente sobrepase el límite.
        drawLines(true)
      end

      if Input.trigger?(Input::UP) and @pos - @lines > 0
        @canvas.clear
        @pos-=@lines+1
        @totalheight = 0
        @w = 0
        #Mismo funcionamiento que al iniciar la pantalla.
        drawLines()
      end

      if Input.trigger?(Input::B) #Cerrar
        @canvas.clear
        @canvas.dispose
        @sprite.dispose
        @viewport.dispose
        Input.update
        Graphics.update
        break
      end

      Input.update
      Graphics.update
    end
  end
end

class Scene_Map #Añade la acción de Input F en Scene_Map para abrir el log
  alias update_old update
  def update
    if Input.trigger?(Input::F)
      Log.new
    end
    update_old
  end
end


class PokemonGlobalMetadata #Añade la variable global log, que guarda todo.
  attr_accessor :log
  alias kyu_initialize initialize
  def initialize
    kyu_initialize
    @log ||= []
  end
end

module NameBox #Implementación para dar compatibilidad a la textbox de Bezier.
  def self.getName
    color = shadowc3tag(@namebox.baseColor,@namebox.shadowColor)
    return color+@namebox.text
  end
end

def getLineChunks(value) #Divide un texto en varias líneas en función de PADX
  regex = [/<[cC][^>]*>/,/<\/[cC][^>]*>/,/<[bB]>/,/<\/[bB]>/,/<[iI]>/,/<\/[iI]>/,
  /<[uU]>/,/<\/[uU]>/,/<[sS]>/,/<\/[sS]>/,/<outln>/,/<\/outln>/,/<outln2>/,
  /<\/outln2>/,/<fn=\d+>/,/<\/fn>/,/<fs=\d+>/,/<\/fs>/,/<[oO]=\d*>/,/<\/[oO]>/,
  /<ac>/,/<\/ac>/,/<al>/,/<\/al>/,/<ar>/,/<\/ar>/]
  bitmap = Bitmap.new(Graphics.width - 2*PADX,Graphics.height)
  width = Graphics.width - 2*PADX
  pbSetSystemFont(bitmap)
  totalwidth = 0 #Anchura total de la línea actual
  count = 0 #Línea actual

  #Color, bold, italic, underlined, struck, outline, thickoutline, font,
  #fontsize, opacity, centered, left-centered,righ-centered
  regs=["","","","","","","","","","","","",""]
  ret=[""] #Array con todas las líneas del texto.

  value = value.clone
  text = []

  #Adding line breaks after alignments
  value.gsub!(/<ac>/,"\n<ac>")
  value.gsub!(/<\/ac>/,"</ac>\n")
  value.gsub!(/<al>/,"\n<al>")
  value.gsub!(/<\/al>/,"</al>\n")
  value.gsub!(/<ar>/,"\n<ar>")
  value.gsub!(/<\/ar>/,"</ar>\n")

  #Procesamiento de los saltos de línea
  while value[/.*((\n)|(<br\/>))/] != nil
    val = value.slice!(/.*((\n)|(<br\/>))/)
    if val[/<r>/]
      val.gsub!(/<r>/,"<ar>")
      val.insert(-2,"</ar>")
    end
    text.push(val)
  end
  #Añade lo que queda después de los saltos de línea
  text.push(value)

  #Análisis de todas las palabras del texto línea por línea
  text.each{|line|
    words = line.split
    aux = []
    words.each_index{|i|
      if words[i][/<[^>]*>(<[^>]*>|\w+)/] != nil
        val = words[i].slice!(/<[^>]*>/)
        aux.push(val)
        aux.push(words[i])
      elsif words[i][/\w+<[^>]*>/] != nil
        val = words[i].slice!(/<[^>]*>/)
        aux.push(words[i])
        aux.push(val)
      else
        aux.push(words[i])
      end
    }
    words = aux
    init = "" #Expresiones de apertura Ej: <fs=X>
    ending = "" #Expresiones de cierre Ej: </fs>

    words.each{|word|
        if word[/^<.*>$/] == nil
          word+= " "
        end
        init = "" #Expresiones de apertura Ej: <fs=X>
        ending = "" #Expresiones de cierre Ej: </fs>

        #Detecta comandos especiales y los activa en regs hasta que encuentra
        #el de cierre.
        regex.each_index{|index|
          aux = word.slice!(regex[index])
          if aux != nil
            if index % 2 != 0 #Comando de cierre
              if index == 1
                regs[0].slice!(/[^<]*<[cC][^>]*>$/)
                regs[0] = DEFAULTCOLOR
                ending += DEFAULTCOLOR
              else
                regs[((index+1)/2)-1]=""
              end
              ending += aux
              if index == 14 #</fn>
                pbSetSystemFont(bitmap)
              elsif index == 3 #</b>
                bitmap.font.bold = false
              elsif index == 5 #</i>
                bitmap.font.italic = false
              end
            else #Comando de apertura
              regs[index/2] = aux
              init += aux
              if index == 14 #<fn=X>
                bitmap.font.name = aux.gsub(/fn=/){""}
              elsif index == 2 #<b>
                bitmap.font.bold = true
              elsif index == 4 #<i>
                bitmap.font.italic = true
              end
            end
          end
        }

        #En word solo queda la palabra neta sin comandos especiales. Se mide
        #cuanto ocupa en bitmap y se añade a totalwidth. En función de ello
        #se realiza un salto de línea o no.
        wordwidth = bitmap.text_size(word).width
        totalwidth += wordwidth
        if totalwidth > width
          count += 1
          ret.push("")
          regs.each{|reg|
            ret[count]+=reg
          }
          ret[count]+= word + ending
          totalwidth = wordwidth
        else
          ret[count] += (init + word + ending)
        end
      }
      count += 1
      ret.push("")
      regs.each{|reg|
        ret[count]+=reg
        }
      ret[count]+=ending
      totalwidth = 0
    }
  return ret
end

################################################################################
#Este método sirve para cambiar los colores de los textos de una textbox para
#el textlog.
#Para añadir un nuevo color, basta con añadir una línea como esta:
#text.gsub!(tag_a_sustituir, nueva_tag)
################################################################################
def changeSkinColor(text)
    text = text.clone
    text.gsub!("<c2=421F2117>", "<c3=3050c8,c9cbd1>")  # Blue
    text.gsub!("<c3=E82010,F8A8B8>", "<c3=F83018,F8B0A0>")  # Red
    text.gsub!("<c2=7FF05EE8>", "<c2=7FF05EE8>")  # Yellow
    text.gsub!("<c2=7E1F5D17>", "<c2=7E1F5D17>")  # Magenta
    text.gsub!("<c2=43FF22F7>", "<c2=43FF22F7>")  # Cyan
    text.gsub!("<c2=63184210>", "<c2=63184210>")  # Grey
    text.gsub!("<c2=7FFF5EF7>", "<c2=7FFF5EF7>")  # White
    text.gsub!("<c2=6546675A>","<c3=3050c8,c9cbd1>") #\b
    text.gsub!("<c2=043C675A>","<c3=F83018,F8B0A0>") #\r
    return text
end