/*
See LICENSE folder for this sample’s licensing information.

Abstract:
An `SCNNode` subclass demonstrating a basic use of `ARSCNFaceGeometry`.
*/

import ARKit
import SceneKit

class Mask: SCNNode, VirtualFaceContent {

    var faceOrigin: SCNNode?
    var lastX: Float = 0.0
    var lastY: Float = 0.0
    var state: Int = 0
    var buffer: Array<Float>?

    init(geometry: ARSCNFaceGeometry) {
        let material = geometry.firstMaterial!

        material.diffuse.contents = UIColor.lightGray
        material.lightingModel = .physicallyBased

        super.init()
        self.geometry = geometry

        faceOrigin = loadedContentForAsset(named: "coordinateOrigin")
        addChildNode(faceOrigin!)
        faceOrigin?.position.z = 0.05;
    }

    required init?(coder aDecoder: NSCoder) {
        fatalError("\(#function) has not been implemented")
    }

    // MARK: VirtualFaceContent

    /// - Tag: SCNFaceGeometryUpdate
    func update(withFaceAnchor anchor: ARFaceAnchor) {
        let faceGeometry = geometry as! ARSCNFaceGeometry
        faceGeometry.update(from: anchor.geometry)
        let nosePos: SCNVector3 = faceOrigin!.worldPosition
        let facePos: SCNVector3 = self.worldPosition
        let vector: SCNVector3 = SCNVector3(
            nosePos.x - facePos.x,
            nosePos.y - facePos.y,
            nosePos.z - facePos.z
        )

        /* Calculate the fromula */
        let t = (-facePos.z)/vector.z
        let newX = facePos.x + vector.x * t
        let newY = facePos.y + vector.y * t

        let offsetX = newX - self.lastX
        let offsetY = newY - self.lastY

        //print(offsetY)

        if self.state == 0 {
            if offsetY < 0 && offsetY < -0.005 {
                state = 1
                self.buffer = Array()
            }
        } else if self.state == 1 {
            if self.buffer?.count == 60 {
                if let buffer = self.buffer {
                    var summary: Float = 0.0
                    for elemt in buffer {
                        if elemt < 0 {
                            summary -= elemt
                        } else {
                            summary += elemt
                        }
                    }
                    print(summary, buffer)
                }
                self.state = 0
            } else {
                let scale: Float = 10000
                self.buffer?.append(offsetY * scale)
            }
        }

        // Update the position
        self.lastX = newX
        self.lastY = newY
    }
}