-----------------------------------------------------------------------------------------
-- BMF.LUA
--
-- Unfortunatly I can not find the original author of bmf.Lua.
-- I would like to provide reference back, so if anyone has
-- a contact, please let me know.
--
-- Modifications by adamrob.co.uk from previous free release.
--
-- Please visit www.adamrob.co.uk
--
-- Updated: 29MAR2014
--
-- > Removed Sprite class functions
--   Sprite module was depreciated from corona graphics version 2.0
--   Replaced with display module
--
-- > Changed BMF.LUA from a module based code to a LUA table
--   This is to make the code more efficient when integration with a
--   corona project
--
-- > Removed references to 'setReferencePoint' function as depreciated
--   from corona graphics version 2.0
--   Replaced with anchor x, and anchor y properties.
--   This also required anchor points to be set in each group
--
-- > Added the ability to re-size the font via scaling
--   By passing in the orignal size.
--   Also added new functions to retreive actual height and width.
--   This is because scaling the font will not update the groups
--   height and width
--
-- > Added paragraph function
--   Enables you to input as much text as you like and capping it to 
--   the max width passed in
--
--
-- Updated: 22APR2013
--
-- > Split the load font function
--   Now enables us to load a .fnt format file and also a font defined
--   purely using lua and corona SDK (using font sheets)
--
-- Updated: 12DEC2015
--
-- > Added size property.
--   Size property can now be adjusted
--
-----------------------------------------------------------------------------------------

local bmFont = {};
local sbFont_mt = { __index = sbFont };
local utf8 = require('font.bmf_utf8')
 
----------------------------
-- Load Fonts
----------------------------

-- ANGEL CODE (.FNT)
-- Specify an Angelcode format bitmap font definition file (".FNT")
-- Return value is a font object that can be used when calling newfntString
-- Call eg: bmFont.loadfntFont( "myFont.fnt" , "fonts/" )
function bmFont.loadfntFont( fntFile, path )
    local function extract( s, p )
        return string.match( s, p ), string.gsub( s, p, '', 1 )
    end
    local path = path or ""
    local font = { info = {}, spritesheets = {}, sprites = {}, chars = {}, kernings = {} }
    local readline = io.lines( system.pathForFile( path..fntFile, system.ResourceDirectory ) )
    for line in readline do
        local t = {}; local tag;
        tag, line = extract( line, '^%s*([%a_]+)%s*' )
        while string.len( line ) > 0 do
            local k, v
            k, line = extract( line, '^([%a_]+)=' )
            if not k then
                break
            end
            v, line = extract( line, '^"([^"]*)"%s*' )
            if not v then
                v, line = extract( line, '^([^%s]*)%s*' )
            end
            if not v then
                break
            end
            t[ k ] = v
        end
        if tag == 'info' or tag == 'common' then
            for k, v in pairs( t ) do font.info[ k ] = v end
        elseif tag == 'page' then
            font.spritesheets[ 1 + t.id ] = { file = t.file, frames = {} }
        elseif tag == 'char' then
            t.letter = string.char( t.id )
            font.chars[ t.letter ] = {}
            for k, v in pairs( t ) do font.chars[ t.letter ][ k ] = v end
            if 0 + font.chars[ t.letter ].width > 0 and 0 + font.chars[ t.letter ].height > 0 then
                font.spritesheets[ 1 + t.page ].frames[ #font.spritesheets[ 1 + t.page ].frames + 1 ] = {
                    x = 0 + t.x, y = 0 + t.y, width = 0 + t.width, height = 0 + t.height,
                }
                font.sprites[ t.letter ] = {
                    spritesheet = 1 + t.page,
                    frame = #font.spritesheets[ 1 + t.page ].frames
                }
            end
        elseif( tag == 'kerning' ) then
            font.kernings[ string.char( t.first ) .. string.char( t.second ) ] = 0 + t.amount
        end
    end
    for k, v in pairs( font.spritesheets ) do
        font.spritesheets[ k ].sheet =graphics.newImageSheet( path..v.file, v )
    end
    for k, v in pairs( font.sprites ) do
        font.sprites[ k ].frame = v.frame
    end
        
    function font:dispose()
        for k in pairs( self.spritesheets ) do
            self.spritesheets[ k ].sheet:dispose()
        end
    end
        
    return font
end
 
-- CORONA GRAPHICS 2 (.LUA)
-- Specify the lua file that holds the font configuration
-- Return value is a font object that can be used when calling newluaString
-- Call eg: bmFont.loadluaFont( "fonts.myFont" )
function bmFont.loadluaFont( fntFile, path )
    local fontDef = require(path.. '.' ..fntFile)
    local options =
    {
        frames = fontDef.frames,
    }
    local fontSheet = graphics.newImageSheet( path .. '/' .. fntFile .. ".png", options )
    local newFont ={}
    newFont.sheet = fontSheet
    newFont.mapping = fontDef.mapping
    newFont.kernings = fontDef.kernings
    newFont.frames = fontDef.frames
    newFont.info = fontDef.info
    return newFont
end


----------------------------
-- Helper Functions
----------------------------

-- extend an object with accessor behaviors
local function accessorize( t )
    local mt = getmetatable( t )
    setmetatable( t, {
    __index = function( t, k )
        if rawget( t, 'get_'..k ) then
            return rawget(t, 'get_'..k )( t, k )
        elseif rawget( t, 'raw_'..k ) then
            return rawget( t, 'raw_'..k )
        elseif mt.__index then
            return mt.__index( t, k )
        else
            return nil
        end
    end,
    __newindex = function( t, k, v )
        if rawget( t, 'set_'..k ) then
            rawget( t, 'set_'..k )( t, k, v )
        elseif rawget( t, 'raw_'..k ) then
            rawset( t, 'raw_'..k, v )
        elseif mt.__newindex then
            mt.__newindex( t, k, v )
        else
            rawset( t, 'raw_'..k, v )
        end
    end,
    } )
end


-- extend an object with cascading removeSelf
local function removerize( t )
    local old = t.removeSelf
    t.removeSelf = function( o )
    for i = o.numChildren, 1, -1 do o[ i ]:removeSelf() end
        old( o )
    end
end

--find the sheet index for the unicode char
local function sheetIndexForChar(font,c)
    local index
    if (c) then
        index = font.mapping[tostring(c)]
    else
        index = nil
    end
    return index
end


----------------------------
-- Create Text
----------------------------

-- ** .FNT Font
-- Pass a font object (obtained from loadFont) and a string to render
-- Return value is a DisplayObject of the rendered string
-- object.font can be read/modifed
-- object.text can be read/modified
-- object.align can be read/modified - left/right/center
-- object.size can be read/modified
--
-- :getHeight() will return the actual height taken up by the text
-- :getWidth() will return the actual width taken up by the text

function bmFont.newfntString( font, text, origsize, newsize)
  
  local finalScale  = 100/origsize *newsize/100;
  
  local obj = display.newGroup()
  obj.anchorChildren = true
  --obj.anchorX=0;
  --obj.anchorY=0;
  
  accessorize( obj )
  removerize( obj )
  
  obj.set_font = function( t, k, v )
    obj.raw_font = v
    if t.text then t.text = t.text end
  end
  
  
  obj.set_align = function( t, k, v )
        t.anchorChildren = true
        
        local w = t.contentWidth
        
        if t.raw_align == 'right' then
            for i = 1, t.numChildren do
                t[ i ].x = t[ i ].x - w
            end
        elseif t.raw_align == 'center' then
            for i = 1, t.numChildren do
                t[ i ].x = t[ i ].x + math.floor( w * 0.5 )
            end
        end
        
        t.raw_align = v
        if t.raw_align == 'right' then
            for i = 1, t.numChildren do
                t[ i ].x = t[ i ].x + w
            end
        elseif t.raw_align == 'center' then
            for i = 1, t.numChildren do
              t[ i ].x = t[ i ].x - math.floor( w * 0.5 )
            end
        elseif t.raw_align ~= 'left' then
            t.raw_align = 'left'
        end
  end
  
  
  obj.set_text = function( t, k, v )
        t.raw_text = v
        t.anchorChildren = true
        --t.anchorX=0.5;
        --t.anchorY=0.5;
        
        for i = t.numChildren, 1, -1 do t[i]:removeSelf() end
        
        local oldAlign = ( t.align or 'left' )
        --t.align = 'left'
        
        local x = 0; local y = 0
        local last = ''; local xMax = 0; local yMax = 0
        
        if t.raw_font then
            for c in string.gmatch( t.raw_text..'\n', '(.)' ) do
                if c == '\n' then
                    x = 0; y = y + t.raw_font.info.lineHeight
                    if y >= yMax then
                        yMax = y
                    end
                elseif t.raw_font.chars[ c ] then
                    if 0 + t.raw_font.chars[ c ].width > 0 and 0 + t.raw_font.chars[ c ].height > 0 then
                        local letter = display.newImage( font.spritesheets[ t.raw_font.sprites[ c ].spritesheet ].sheet, t.raw_font.sprites[ c ].frame)
                        letter.anchorX=0;
                        letter.anchorY=0;
                        if t.raw_font.kernings[ last .. c ] then
                            x = x + font.kernings[ last .. c ]
                        end
                        letter.x = t.raw_font.chars[ c ].xoffset + x
                        letter.y = t.raw_font.chars[ c ].yoffset - t.raw_font.info.base + y

                        t:insert( letter )
                        last = c
                    end
                    x = x + t.raw_font.chars[ c ].xadvance
                    if x >= xMax then
                        xMax = x
                    end
                end
            end
        end
        t.align = oldAlign
    end

    obj.set_size = function( t, k, v )
        --Get the new size value
        t.raw_size=v
        --Work out the scale factor again and re-apply
        local finalScale  = 100/origsize *v/100;
        t.xScale=finalScale
        t.yScale=finalScale
        --Re-align text
        local oldAlign = ( t.align or 'left' )
        t.align=oldAlign
    end
    
  obj.font = font
  obj.text = (text or '')
  obj.align = 'left'
  obj.size=newsize
  
  obj.xScale = finalScale;
  obj.yScale = finalScale;


  function obj:getHeight()
    return obj.height * finalScale
  end

  function obj:getWidth()
    return obj.width * finalScale
  end


  return obj
end


-- ** LUA Font
-- Pass a font object (obtained from loadFont) and a string to render
-- Return value is a DisplayObject of the rendered string
-- object.font can be read/modifed
-- object.text can be read/modified
-- object.align can be read/modified - left/right/center
-- object.input( function(text), { filter = function(), max = 32 } )
--   turns the object into a text input.
--   the callback is hit when the user presses "return" or the field losed focus.
--   this code is under development - more documentation will be added soon...
--
-- :getHeight() will return the actual height taken up by the text
-- :getWidth() will return the actual width taken up by the text

function bmFont.newluaString( font, text )
  local obj = display.newGroup()
  obj.anchorChildren = true
  accessorize( obj )
  removerize( obj )
  obj.set_font = function( t, k, v )
    obj.raw_font = v
    if t.text then t.text = t.text end
  end
  obj.set_align = function( t, k, v )
        local w = t.contentWidth
        if t.raw_align == 'right' then
            for i = 1, t.numChildren do
                t[ i ].x = t[ i ].x - w
            end
        elseif t.raw_align == 'center' then
            for i = 1, t.numChildren do
                t[ i ].x = t[ i ].x + math.floor( w * 0.5 )
            end
        end
        t.raw_align = v
        if t.raw_align == 'right' then
            for i = 1, t.numChildren do
                t[ i ].x = t[ i ].x + w
            end
        elseif t.raw_align == 'center' then
            for i = 1, t.numChildren do
              t[ i ].x = t[ i ].x - math.floor( w * 0.5 )
            end
        elseif t.raw_align ~= 'left' then
            t.raw_align = 'left'
        end
  end
  obj.set_text = function( t, k, v )
        t.raw_text = v
        
        for i = t.numChildren, 1, -1 do t[i]:removeSelf() end
        local oldAlign = ( t.align or 'left' )
        t.align = 'left'
        local x = 0; local y = 0
        local last = 0; local xMax = 0; local yMax = 0
        local unicode = 0
        if t.raw_font then
            if display.contentScaleX == .5 then 
                t.raw_font.info.lineHeight = t.raw_font.info.lineHeight /2
            end
        
            for i, c, b in utf8.chars(t.raw_text) do
                unicode = utf8.unicodeValue(c)
                if c == '\n' then
                    x = 0; 
                    y = y + t.raw_font.info.lineHeight
                    if y >= yMax then
                        yMax = y
                    end
                elseif t.raw_font.mapping[ tostring(unicode) ] then 
                    local fntFrame = t.raw_font.frames[sheetIndexForChar(t.raw_font,unicode)]
                    if (fntFrame) then
                    if 0 + t.raw_font.frames[sheetIndexForChar(t.raw_font,unicode)].width > 0 and 0 + t.raw_font.frames[sheetIndexForChar(t.raw_font,unicode)].height > 0 then
                        local spriteOptions = { name=tostring(unicode), start=sheetIndexForChar(t.raw_font,unicode), count=1 }
                        local letter = display.newSprite( t.raw_font.sheet, spriteOptions )
                        
                        letter.anchorX = 0
                        letter.anchorY = 0
                        letter.x = 0
                        letter.y = 0

                        if (last ~= 0) then
                        
                        if t.raw_font.kernings[ tostring(last) ..",".. tostring(unicode) ] then
                            x = x + font.kernings[ tostring(last) ..",".. tostring(unicode)  ]
                        end
                        end
                        if display.contentScaleX == .5 then --scale the highres spritesheet if you're on a retina device.
                        
                            letter.xScale = .5
                            letter.yScale = .5
                            letter.x = t.raw_font.frames[ sheetIndexForChar(t.raw_font,unicode) ].xoffset/2 + x
                            letter.y = t.raw_font.frames[ sheetIndexForChar(t.raw_font,unicode) ].yoffset/2 - t.raw_font.info.base + y
                        else
                            letter.x = t.raw_font.frames[ sheetIndexForChar(t.raw_font,unicode) ].xoffset + x
                            letter.y = t.raw_font.frames[ sheetIndexForChar(t.raw_font,unicode) ].yoffset - t.raw_font.info.base + y
                        end
                        
                        t:insert( letter )
                        last = c
                    end
                    
                    if display.contentScaleX == .5 then 
                        x = x + t.raw_font.frames[ sheetIndexForChar(t.raw_font,unicode) ].xadvance/2
                    else
                        x = x + t.raw_font.frames[ sheetIndexForChar(t.raw_font,unicode) ].xadvance
                    end
                    if x >= xMax then
                        xMax = x
                    end
                    end
                end
            end
          local background = display.newRect( 0, -t.raw_font.info.base, xMax, yMax )
          obj:insert( background )
          background:setFillColor( 0, 0, 0, 0 )
        end
        t.align = oldAlign
    end
    obj.input = function( f, args )
        -- spawn the text field invisibly
        local field
        local function char()
            -- check if any character has been added or deleted
            if field.text ~= '--' then
                if string.len( field.text ) < 2 then
                    -- backspace was pressed
                    if string.len( obj.text ) > 0 then
                        obj.text = string.sub( obj.text, 1, -2 )
                    end
                else
                    -- some other key was pressed
                    obj.text = obj.text..string.sub( field.text, 3 )
                end
                field.text = '--'
                if args.filter then
                    obj.text = string.sub( args.filter( obj.text ), 1, (args.max or 32) )
                else
                    obj.text = string.sub( obj.text, 1, (args.max or 32) )
                end
            end
        end
        Runtime:addEventListener( 'enterFrame', char )
        local function done( e )
            if e.phase == 'submitted' or e.phase == 'ended' then
                native.setKeyboardFocus( nil )
                field:removeSelf()
                Runtime:removeEventListener( 'enterFrame', char )
                f( text )
            end
        end
        field = native.newTextField( 0, 0, 240, 24, done )
        field.text = '--'
        field.isVisible = false
        native.setKeyboardFocus( field )
    end
    obj.font = font
    obj.align = 'left'
  obj.text = (text or '')
  return obj
end




----------------------------
-- Create Paragraph
----------------------------

-- ** .FNT Font
-- Pass a font object (obtained from loadFont)
-- Pass the text string to render
-- Pass the original size of the font
-- Pass the required size of the font
-- Pass the width of the text block. The text will append with multiple lines if required
-- Return value is a DisplayObject of the rendered string

-- object.font can be read/modifed
-- object.text can be read/modified
-- object.align can be read/modified - left/right/center
--
-- :getHeight() will return the actual height taken up by the text
-- :getWidth() will return the actual width taken up by the text

function bmFont.newfntParagraph(font, text, origsize, newsize, width)
    local obj = display.newGroup()
    obj.anchorChildren = true --Anchor so text will stay in the correct place in the group
    local finalScale  = 100/origsize *newsize/100;
    
    accessorize( obj )
    removerize( obj )

    obj.set_font = function( t, k, v )
        obj.raw_font = v
        --if t.text then t.text = t.text end
    end

    obj.set_paragraphWidth = function( t, k, v )
        obj.raw_paragraphWidth = v
        --if t.text then t.text = t.text end
    end

    obj.set_tint = function( t, k, v )
        obj.raw_tint = v
        for i = t.numChildren, 1, -1 do
            for j = t[i].numChildren, 1, -1 do
                if(not t[i][j].isBackground) then
                    if v[4] then
                        t[i][j]:setFillColor(v[1],v[2],v[3],v[4])
                    else
                        t[i][j]:setFillColor(v[1],v[2],v[3])
                    end
                end
            end
        end
        --if t.text then t.text = t.text end
    end

    obj.set_align = function( t, k, v )
        t.anchorChildren = true
        
        local w = t.contentWidth

        --local placeholder for x offsets
        local lineOffset={}
        --Loop through each line
        for i = 1, #t.lineWidth do

            --check paragraph width is greater than the line width
            if (width > t.lineWidth[i]) then
                --Work out the offset
                lineOffset[i] = (width - t.lineWidth[i])
            end
        end
        
        if t.raw_align == 'right' then
            for i = 1, t.numChildren do
                t[ i ].x = t[ i ].x - w
            end
        elseif t.raw_align == 'center' then

            for i = 1, t.numChildren do
                t[ i ].x = t[ i ].x + math.floor( width * 0.5 )
            end
        end
        
        --Find out what we need to set the alignment to
        t.raw_align = v
        if t.raw_align == 'right' then
            --Loop through each word to move its x pos
            for i = 1, t.numChildren do
                --Move the word
                t[ i ].x = t[ i ].originalX + lineOffset[t[i].line]*2
            end

        elseif t.raw_align == 'center' then
            
            --Loop through each word to move its x pos
            for i = 1, t.numChildren do
                --Move the word
                t[ i ].x = t[ i ].originalX + lineOffset[t[i].line]
            end

        elseif t.raw_align == 'left' then
            --Loop through each word to move its x pos
            for i = 1, t.numChildren do
                --Move the word
                t[ i ].x = t[i].originalX
            end

        elseif t.raw_align ~= 'left' then
            t.raw_align = 'left'
        end
  end

    obj.set_text = function(t, k, v)
        t.anchorChildren = true
        --save the new raw text
        t.raw_text = v

        --remove all children
        for i = t.numChildren, 1, -1 do
            t[i]:removeSelf()
        end

        spaceWidth=0

        --Create our word-wrapped paragraph.
        local spaceLeft = t.raw_paragraphWidth
        local x, y = obj.x, obj.y
        local iLine =1
        obj.lineWidth={}

        for word, spacer in string.gmatch(v, "([^%s%-]+)([%s%-]*)") do
            local w = bmFont.newfntString(font, word..spacer,origsize, origsize)

            --Check if the width of the word will fit in the remaining space of the line
            if(w.width + spaceWidth) > spaceLeft then
                --Word won't fit on the line
                spaceLeft = t.raw_paragraphWidth - w.width - spaceWidth
                --Set height and width for a new line
                y = y + w.raw_font.info.lineHeight
                x = obj.x
                w.x = x

                --Add line info
                iLine=iLine+1
                w.line=iLine
            else
                --Word will fit, so carry on on the same line
                w.x = x + t.raw_paragraphWidth - spaceLeft
                spaceLeft = spaceLeft - w.width - spaceWidth

                --Add line info
                w.line=iLine
            end
            --Set y position
            w.y = y

            --Anchor at 0,0 ton ensure text is tight to the display group
            w.anchorX=0;
            w.anchorY=0;

            --Save the original X position for alignment later
            w.originalX=w.x

            --Work out the line width
            if (obj.lineWidth[iLine]==nil) then
                obj.lineWidth[iLine] = 0
            end
            obj.lineWidth[iLine] = obj.lineWidth[iLine] + (w.width * finalScale)


            --Insert the word into the paragraph group
            obj:insert(w)
        end
    end

    obj.paragraphWidth = width or display.viewableContentWidth
    obj.text = text
    obj.font = font
    --obj.tint = {255,255,255}
    --obj.align = 'center'


    obj.xScale = finalScale;
    obj.yScale = finalScale;

      function obj:getHeight()
        return obj.height * finalScale
      end

      function obj:getWidth()
        return obj.width * finalScale
      end

    return obj
end



function bmFont.destroy()
    -- Nothing to Destroy, yet
end
 
return bmFont