local pinchlibapi = require("pinchlib")
 
display.setStatusBar( display.HiddenStatusBar )
system.activate( "multitouch" )
 
--[[ There is no reason that the device environment could use display objects and stage:setFocus to track touch events... ]]--
 
--[[ This section handles the simulator interaction which is performed by display objects representing touches. ]]--
 
local stage = display.getCurrentStage()
 
-- use display group to allow image switching during scaling
local img = display.newGroup()
 
-- load smaller version of image
img.x1 = display.newImage( img, "yoda.png" )
img.x1.x, img.x1.y = 0, 0 -- place image in centre of pinched group
 
-- load larger version of image (this would normally be done lazily, to save memory)
img.x2 = display.newImage( img, "scene.png" )
img.x2.x, img.x2.y = 0, 0 -- place image in centre of pinched group
img.x2.xScale, img.x2.yScale = .5, .5 -- scale large version so it doesn't jump when coming into view
img.x2.alpha = 0 -- hide the larger version
 
img.x, img.y = display.contentCenterX, display.contentCenterY
 
-- handles calling the pinch for simulator
function simPinch()
        local points = {}
        for i=1, stage.numChildren do
                if (stage[i].name == "touchpoint") then
                        points[#points+1] = stage[i]
                end
        end
        pinchlibapi.doPinchZoom( img, points )
        
        -- handle the image switching
        if (img.xScale < 2) then
                img.x2.alpha = 0 -- hide the larger scale image if below 2x scale
        else
                img.x2.alpha = 1 -- show the higher quality image if scaled large enough
        end
        
        -- for simulator, print the scaling info
        print(img.xScale, img.yScale)
end
 
-- handles the simulator
function tap(event)
        local circle = display.newCircle(event.x, event.y, 25)
        circle.name = "touchpoint"
        circle.id = system.getTimer()
        circle.strokeWidth = 2
        circle:setStrokeColor(255,0,0)
        circle:setFillColor(0,0,255)
        circle.alpha = .6
        circle:addEventListener("tap", circle)
        circle:addEventListener("touch", circle)
        
        function circle:tap(event)
                circle:removeEventListener("tap",self)
                circle:removeEventListener("touch",self)
                circle:removeSelf()
                -- reset pinch data to avoid jerking the image when the average centre suddenly moves
                simPinch()
                return true
        end
        
        function circle:touch(event)
                if (event.phase == "began") then
                        stage:setFocus(circle)
                elseif (event.phase == "moved") then
                        circle.x, circle.y = event.x, event.y
                elseif (event.phase == "ended" or event.phase == "cancelled") then
                        circle.x, circle.y = event.x, event.y
                        stage:setFocus(nil)
                end
                
                simPinch()
                return true
        end
        
        simPinch()
        return true
end
 
--[[ This section handles device interaction which simply holds a list of the current touch events. ]]--
 
local touches = {}
 
-- handles calling the pinch for device
function devPinch( event, remove )
        -- look for event to update or remove
        for i=1, #touches do
                if (touches[i].id == event.id) then
                        -- update the list of tracked touch events
                        if (remove) then
                                table.remove( touches, i )
                        else
                                touches[i] = event
                        end
                        -- update the pinch
                        pinchlibapi.doPinchZoom( img, touches )
                        return
                end
        end
        -- add unknown event to list
        touches[#touches+1] = event
        pinchlibapi.doPinchZoom( img, touches )
        
        -- handle the image switching
        if (img.xScale < 2) then
                img.x2.alpha = 0 -- hide the larger scale image if below 2x scale
        else
                img.x2.alpha = 1 -- show the higher quality image if scaled large enough
        end
end
 
-- handles the device
function touch(event)
        -- handle the touch
        if (event.phase == "began") then
                pinchlibapi.doPinchZoom( img,{} )
                devPinch( event )
        elseif (event.phase == "moved") then
                devPinch( event )
        else
                pinchlibapi.doPinchZoom( img,{} )
                devPinch( event, true )
        end
end
 
--[[ This section attaches the appropriate touch/tap handler for the environment (simulator or device). ]]--
-- Please note that the XCode simulator will be handled as 'device' although it has no way to provide multitouch events.
 
if (system.getInfo( "environment" ) == "simulator") then
        Runtime:addEventListener("tap",tap) -- mouse being used to create moveable touch avatars
elseif (system.getInfo( "environment" ) == "device") then
        Runtime:addEventListener("touch",touch) -- fingers being used to create real touch events
end

module(..., package.seeall)
 
local mathlibapi = require("mathlib")
 
-- requires a collection of touch points
-- each point must have '.id' to be tracked otherwise it will be ignored
-- each point must be in world coordinates (default state of touch event coordinates)
function doPinchZoom( img, points )
        -- must have an image to manipulate
        if (not img) then
                return
        end
        
        -- is this the end of the pinch?
        if (not points or not img.__pinchzoomdata or #points ~= #img.__pinchzoomdata.points) then
                -- reset data (when #points changes)
                img.__pinchzoomdata = nil
                
                -- exit if there are no calculations to do
                if (not points or #points == 0) then
                        return -- nothing to do
                end
        end
        
        -- get local ref to zoom data
        local olddata = img.__pinchzoomdata
        
        -- create newdata table
        local newdata = {}
        
        -- store img x,y in world coordinates
        newdata.imgpos = getImgPos( img )
        
        -- calc centre (build list of points for later - avoids storing actual event objects passed in)
        newdata.centre, newdata.points = getCentrePoints( points )
        
        -- calc distances and angles from centre point
        calcDistancesAndAngles( newdata )
        
        -- does pinching need to be performed?
        if (olddata) then
                -- translation of centre
                newdata.imgpos.x = newdata.imgpos.x + newdata.centre.x - olddata.centre.x
                newdata.imgpos.y = newdata.imgpos.y + newdata.centre.y - olddata.centre.y
                
                -- get scaling factor and rotation difference
                if (#newdata.points > 1) then
                        newdata.scalefactor, newdata.rotation = calcScaleAndRotation( olddata, newdata )
                else
                        newdata.scalefactor, newdata.rotation = 1, 0
                end
                
                -- scale around pinch centre (translation)
                newdata.imgpos.x = newdata.centre.x + ((newdata.imgpos.x - newdata.centre.x) * newdata.scalefactor)
                newdata.imgpos.y = newdata.centre.y + ((newdata.imgpos.y - newdata.centre.y) * newdata.scalefactor)
                
                -- rotate around pinch centre
                newdata.imgpos = mathlibapi.rotateAboutPoint( newdata.imgpos, newdata.centre, newdata.rotation, false )
                
                -- convert to local coordinates
                local x, y = img.parent:contentToLocal( newdata.imgpos.x, newdata.imgpos.y )
                
                -- apply pinch...
                img.x, img.y = x, y
                img.rotation = img.rotation + newdata.rotation
                img.xScale, img.yScale = img.xScale * newdata.scalefactor, img.yScale * newdata.scalefactor
        end
        
        -- store new data
        img.__pinchzoomdata = newdata
end
 
-- simply converts the display object's centre x,y into world coordinates
function getImgPos( img )
        local x, y = img:localToContent( 0, 0 )
        return { x=x, y=y }
end
 
-- calculates the centre of the points
-- generates a new list of points so we are not storing the list of events from calling code
function getCentrePoints( points )
        local x, y = 0, 0
        local newpoints = {}
        
        for i=1, #points do
                -- accumulate the centre values
                x = x + points[i].x
                y = y + points[i].y
                
                -- record the point with it's associated data
                newpoints[#newpoints+1] = { x=points[i].x, y=points[i].y, id=points[i].id }
        end
        
        -- return the list of points for next time and the centre point of this list
        return
                { x = x / #points, y = y / #points }, -- centre
                newpoints -- list of points
end
 
-- calculates the distance from the centre to each point and their angle if the centre is assumed to be 0,0
function calcDistancesAndAngles( data )
        for i=1, #data.points do
                data.points[i].length = mathlibapi.lengthOf( data.centre, data.points[i] )
                data.points[i].angle = mathlibapi.angleBetweenPoints( data.centre, data.points[i] )
        end
end
 
-- calculates the change in scale between the old and new points
-- also calculates the change in rotation around the centre point
-- uses their average change
function calcScaleAndRotation( olddata, newdata )
        local scalediff, anglediff = 0, 0
        
        for i=1, #newdata.points do
                local oldpoint = getPointById( newdata.points[i], olddata.points )
                
                scalediff = scalediff + newdata.points[i].length / oldpoint.length
                anglediff = anglediff + mathlibapi.smallestAngleDiff(newdata.points[i].angle, oldpoint.angle)
        end
        
        return
                scalediff / #newdata.points, -- scale factor
                anglediff / #newdata.points -- rotation average
end
 
-- returns the newpoint if it does not have a previous version, or the old point if it has simply moved
function getPointById( newpoint, points )
        for i=1, #points do
                if (points[i].id == newpoint.id) then
                        return points[i]
                end
        end
        return newpoint
end

module(..., package.seeall)
 
 
-- returns the distance between points a and b
function lengthOf( a, b )
    local width, height = b.x-a.x, b.y-a.y
    return math.sqrt(width*width + height*height)
end
 
-- converts degree value to radian value, useful for angle calculations
function convertDegreesToRadians( degrees )
--      return (math.pi * degrees) / 180
        return math.rad(degrees)
end
 
function convertRadiansToDegrees( radians )
        return math.deg(radians)
end
 
-- rotates a point around the (0,0) point by degrees
-- returns new point object
function rotatePoint( point, degrees )
        local x, y = point.x, point.y
        
        local theta = convertDegreesToRadians( degrees )
        
        local pt = {
                x = x * math.cos(theta) - y * math.sin(theta),
                y = x * math.sin(theta) + y * math.cos(theta)
        }
 
        return pt
end
 
-- rotates point around the centre by degrees
-- rounds the returned coordinates using math.round() if round == true
-- returns new coordinates object
function rotateAboutPoint( point, centre, degrees, round )
        local pt = { x=point.x - centre.x, y=point.y - centre.y }
        pt = rotatePoint( pt, degrees )
        pt.x, pt.y = pt.x + centre.x, pt.y + centre.y
        if (round) then
                pt.x = math.round(pt.x)
                pt.y = math.round(pt.y)
        end
        return pt
end
 
-- returns the degrees between (0,0) and pt
-- note: 0 degrees is 'east'
function angleOfPoint( pt )
        local x, y = pt.x, pt.y
        local radian = math.atan2(y,x)
        --print('radian: '..radian)
        local angle = radian*180/math.pi
        --print('angle: '..angle)
        if angle < 0 then angle = 360 + angle end
        --print('final angle: '..angle)
        return angle
end
 
-- returns the degrees between two points
-- note: 0 degrees is 'east'
function angleBetweenPoints( a, b )
        local x, y = b.x - a.x, b.y - a.y
        return angleOfPoint( { x=x, y=y } )
end
 
-- Takes a centre point, internal point and radius of a circle and returns the location of the extruded point on the circumference
-- In other words: Gives you the intersection between a line and a circle, if the line starts from the centre of the circle
function calcCirclePoint( centre, point, radius )
        local distance = lengthOf( centre, point )
        local fraction = distance / radius
        
        local remainder = 1 - fraction
        
        local width, height = point.x - centre.x, point.y - centre.y
        
        local x, y = centre.x + width / fraction, centre.y + height / fraction
        
        local px, py = x - point.x, y - point.y
        
        return px, py
end
 
-- returns the smallest angle between the two angles
-- ie: the difference between the two angles via the shortest distance
function smallestAngleDiff( target, source )
        local a = target - source
        
        if (a > 180) then
                a = a - 360
        elseif (a < -180) then
                a = a + 360
        end
        
        return a
end