//
//  ViewController.swift
//  utahDemo
//
//  Created by vm mac on 2016-12-02.
//  Copyright © 2016 Michael Aubie. All rights reserved.
//

import GLKit

// a struct for a 2D Vector
struct myVec2 {
    var x:Float
    var y:Float

    mutating func setX (newX: Float){
        x = newX
    }
    mutating func setY (newY: Float){
        y = newY
    }
}


struct block {

    var _position:myVec2
    var _size:Float
    var _isHit:Bool
}



class ViewController: GLKViewController, UIGestureRecognizerDelegate {

    // the shader program
    private var _program: GLuint = 0

    //an amount to scale the player's quad
    private var _scaleX:Float = 5.0
    private var _scaleY:Float = 1.0

    //the speed of the players Xmovement, it will switch between positive and negative
    private var _moveValue:Float = 0.08
    //speed of the bullets
    private let _bulletSpeed:Float = 0.08

    //position of player and bullets
    private var _bulletArray:[myVec2] = []
    private let _playerY:Float = -0.8
    private var _playerPosition:Float = 0.0
    private var _lineOfBlocks: [block] = []



    let triangle: [Float] = [
        -0.5, 0.0,
        0.5, 0.0,
        0.0, 1.0
    ]


    let quad: [Float] = [
        -0.05, -0.05,
        0.05, -0.05,
        -0.05, 0.05,
        0.05, 0.05,

        ]




    override func viewDidLoad() {
        super.viewDidLoad()

        //setup opengl
        let glkView = view as! GLKView
        glkView.context = EAGLContext(api: .openGLES2)
        EAGLContext.setCurrent(glkView.context)
        glkView.drawableColorFormat = .RGBA8888
        EAGLContext.setCurrent(glkView.context)


        setup()


        //recognize taps
        let tap = UITapGestureRecognizer(target: self, action: #selector(ViewController.handleTap))
        tap.delegate = self
        view.addGestureRecognizer(tap)

        //recognize swipe left
        let swipeLeft = UISwipeGestureRecognizer(target: self, action: #selector(ViewController.handleSwipes))
        swipeLeft.direction = .left
        view.addGestureRecognizer(swipeLeft)

        //recognize swipe right
        let swipeRight = UISwipeGestureRecognizer(target: self, action: #selector(ViewController.handleSwipes))
        swipeRight.direction = .right
        view.addGestureRecognizer(swipeRight)


        //add line of blocks
        for x in -8...8 {
            let myNewVec = myVec2(x: Float(x)*0.1, y: 0.8)
            let newBlock = block(_position: myNewVec, _size: _scaleX*0.2, _isHit: false)
            _lineOfBlocks.append(newBlock)
        }
    }


    func handleTap(sender: UITapGestureRecognizer? = nil) {
        // on tap add a new bullet to the array
        let newbullet = myVec2(x: _playerPosition, y: _playerY)
        _bulletArray.append(newbullet)
    }

    func handleSwipes(sender:UISwipeGestureRecognizer) {
        if (sender.direction == .left) {
            if( _moveValue >= 0) { _moveValue *= -1}
        }

        if (sender.direction == .right) {
            if( _moveValue <= 0) { _moveValue *= -1}
        }
    }

    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }

    func setup() {
        glClearColor(0.0, 1.0, 1.0, 1.0)

        var vertexShaderSource: NSString = "" +
            "attribute vec2 position;" +
            "uniform vec2 translate; \n" +
            "uniform vec2 scale; \n" +
            "void main() \n"  +
            "{ \n" as NSString
        vertexShaderSource = (vertexShaderSource as String) +
        "    gl_Position = vec4(position.x * scale.x + translate.x, position.y * scale.y + translate.y, 0.0, 1.0); \n" +
        "} \n" as NSString


        var fragmentShaderSource: NSString = "" +
            "uniform highp vec4 color; \n" +
            "void main() \n"  +
            "{ \n" as NSString
        fragmentShaderSource = (fragmentShaderSource as String) +
            "    gl_FragColor = color; \n" +
            "} \n" as NSString

       let vertexShader: GLuint = glCreateShader(GLenum(GL_VERTEX_SHADER))

        var vertexShaderSourceUTF8 = vertexShaderSource.utf8String
        glShaderSource(vertexShader, 1, &vertexShaderSourceUTF8, nil)
        glCompileShader(vertexShader)
        var vertexShaderCompileStatus: GLint = GL_FALSE
        glGetShaderiv(vertexShader, GLenum(GL_COMPILE_STATUS), &vertexShaderCompileStatus)

        if vertexShaderCompileStatus == GL_FALSE {
            var vertexShaderLogLength: GLint = 0
            glGetShaderiv(vertexShader, GLenum(GL_INFO_LOG_LENGTH), &vertexShaderLogLength)
            let vertexShaderLog = UnsafeMutablePointer<GLchar>.allocate(capacity: Int(vertexShaderLogLength))
            glGetShaderInfoLog(vertexShader, vertexShaderLogLength, nil, vertexShaderLog)
            let vertexShaderLogString: NSString = NSString(utf8String: vertexShaderLog)!
            print("Vertex Shader Compiling failed \(vertexShaderLogString)")

        }

        let fragmentShader: GLuint = glCreateShader(GLenum(GL_FRAGMENT_SHADER))

        var fragmentShaderSourceUTF8 = fragmentShaderSource.utf8String
        glShaderSource(fragmentShader, 1, &fragmentShaderSourceUTF8, nil)
        glCompileShader(fragmentShader)
        var fragmentShaderCompileStatus: GLint = GL_FALSE
        glGetShaderiv(fragmentShader, GLenum(GL_COMPILE_STATUS), &fragmentShaderCompileStatus)

        if fragmentShaderCompileStatus == GL_FALSE {
            var fragmentShaderLogLength: GLint = 0
            glGetShaderiv(fragmentShader, GLenum(GL_INFO_LOG_LENGTH), &fragmentShaderLogLength)
            let fragmentShaderLog = UnsafeMutablePointer<GLchar>.allocate(capacity: Int(fragmentShaderLogLength))
            glGetShaderInfoLog(fragmentShader, fragmentShaderLogLength, nil, fragmentShaderLog)
            let fragmentShaderLogString: NSString = NSString(utf8String: fragmentShaderLog)!
            print("fragment Shader Compiling failed \(fragmentShaderLogString)")

        }

        _program = glCreateProgram()
        glAttachShader(_program, vertexShader)
        glAttachShader(_program, fragmentShader)
        glBindAttribLocation(_program, 0, "position")
        glLinkProgram(_program)
        var programLinkStatus: GLint = GL_FALSE
        glGetProgramiv(_program, GLenum(GL_LINK_STATUS), &programLinkStatus)
        if programLinkStatus == GL_FALSE {
            var ProgramLogLength: GLint = 0
            glGetProgramiv(_program, GLenum(GL_INFO_LOG_LENGTH), &ProgramLogLength)
            let linkLog = UnsafeMutablePointer<GLchar>.allocate(capacity: Int(ProgramLogLength))
            glGetProgramInfoLog(_program, ProgramLogLength, nil, linkLog)
            let linkLogString: NSString? = NSString(utf8String: linkLog)
            print("Program Link Failed \(linkLogString)")
        }

        glUseProgram(_program)
        glEnableVertexAttribArray(0)
    }

    func update() {



        //move the bullets
        for bullet in 0..<_bulletArray.count {
            let newY = _bulletArray[bullet].y + _bulletSpeed
            _bulletArray[bullet].setY(newY: newY)

            //check for collision with blocks
            for block in 0..<_lineOfBlocks.count {
                if abs(_bulletArray[bullet].x - _lineOfBlocks[block]._position.x) < 0.05 &&
                    abs(_bulletArray[bullet].y - _lineOfBlocks[block]._position.y) < 0.05 {
                    _lineOfBlocks[block]._isHit = true
                }

                //move the block down
                _lineOfBlocks[block]._position.y -= 0.0002
            }

            //to do: delete the bullets
        }

        _playerPosition += _moveValue
        if _playerPosition > 0.95 || _playerPosition < -0.95 { _moveValue *= -1}


    }


    override func glkView(_ view: GLKView, drawIn rect: CGRect) {



        glClear(GLbitfield(GL_COLOR_BUFFER_BIT))


        //draws the player
        glVertexAttribPointer(0, 2, GLenum(GL_FLOAT), GLboolean(GL_FALSE), 0, quad)
        glUniform2f(glGetUniformLocation(_program, "translate"), _playerPosition, -0.8)
        glUniform2f(glGetUniformLocation(_program, "scale"), _scaleX, _scaleY)
        glUniform4f(glGetUniformLocation(_program, "color"), 1.0, 0.0, 0.0, 1.0)
        glDrawArrays(GLenum(GL_TRIANGLE_STRIP), 0, 4)




//        //draws the blocks along the top
        for block in 0..<_lineOfBlocks.count {
            let blockPos = block - 8
            glVertexAttribPointer(0, 2, GLenum(GL_FLOAT), GLboolean(GL_FALSE), 0, quad)
            glUniform2f(glGetUniformLocation(_program, "translate"), GLfloat(_lineOfBlocks[block]._position.x), GLfloat(_lineOfBlocks[block]._position.y))
            glUniform2f(glGetUniformLocation(_program, "scale"), _scaleX*0.2, _scaleY)

            if(block<0){
                glUniform4f(glGetUniformLocation(_program, "color"), 0.3, -0.1*GLfloat(blockPos), 0.8, 1.0)
            }
            else{
                glUniform4f(glGetUniformLocation(_program, "color"), 0.3, 0.1*GLfloat(blockPos), 0.8, 1.0)
            }

            if _lineOfBlocks[block]._isHit == false {
                glDrawArrays(GLenum(GL_TRIANGLE_STRIP), 0, 4)
            }


        }


        //draws the bullets
        for bullet in _bulletArray {
            glVertexAttribPointer(0, 2, GLenum(GL_FLOAT), GLboolean(GL_FALSE), 0, triangle)

            glUniform2f(glGetUniformLocation(_program, "translate"), bullet.x, bullet.y)
            glUniform4f(glGetUniformLocation(_program, "color"), 1.0, 0.0, 1.0, 1.0)
            glUniform2f(glGetUniformLocation(_program, "scale"), 0.08, 0.08)
            glDrawArrays(GLenum(GL_TRIANGLES), 0, 3)
        }

    }

    override var canBecomeFirstResponder: Bool {
        return true
    }




}