package dk.riisby.bluetoothcontroller

import android.app.ProgressDialog
import android.bluetooth.BluetoothAdapter
import android.bluetooth.BluetoothDevice
import android.bluetooth.BluetoothSocket
import android.content.Context
import android.os.AsyncTask
import android.support.v7.app.AppCompatActivity
import android.os.Bundle
import android.support.annotation.WorkerThread
import android.util.Log
import android.view.View
import android.widget.SeekBar
import io.github.controlwear.virtual.joystick.android.JoystickView
import kotlinx.android.synthetic.main.activity_control.*
import org.jetbrains.anko.toast
import java.io.IOException
import java.util.*
import java.util.concurrent.Callable
import java.util.concurrent.locks.Condition
import kotlin.concurrent.schedule
import kotlin.concurrent.scheduleAtFixedRate
import kotlin.math.PI
import kotlin.math.cos
import kotlin.math.roundToInt
import kotlin.math.sin

class ControlActivity : AppCompatActivity() {
    val s1 = Sender(128,128,128)
    companion object {
        var m_myUUID: UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB")
        var m_bluetoothSocket: BluetoothSocket? = null
        lateinit var m_progress: ProgressDialog
        lateinit var m_bluetoothAdapter: BluetoothAdapter
        var m_isConnected: Boolean =false
        lateinit var m_address: String
        const val TAG: String = "con_debug"
        var result: Double = 0.toDouble()
        var result2: Double = 0.toDouble()
        val timer = Timer("schedule", true)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_control)
        m_address = intent.getStringExtra(SelectDeviceList.EXTRA_ADDRESS)
        ConnectToDevice(this).execute()
        listen()
        timer.schedule(10000){
            s1.start()
        }
        timer.scheduleAtFixedRate(10100 , 100) {
            s1.run()
        }
    }

    private fun disconnect () {
        if (m_bluetoothSocket != null){
            try {
                m_bluetoothSocket!!.close()
                m_bluetoothSocket= null
                m_isConnected = false
            } catch (e: IOException){
                e.printStackTrace()
            }

        }
        finish()
    }

    private inner class ConnectToDevice(c: Context) : AsyncTask<Void, Void, String>(){
        private var connectSuccess: Boolean = true
        private val context: Context

        init {
            this.context = c
        }
        override fun onPreExecute() {
            super.onPreExecute()
            m_progress = ProgressDialog.show(context, "Connecting...", "please wait")
        }

        override fun doInBackground(vararg p0: Void?): String? {
            try {
                if (m_bluetoothSocket == null || !m_isConnected){
                    m_bluetoothAdapter = BluetoothAdapter.getDefaultAdapter()
                    val device: BluetoothDevice = m_bluetoothAdapter.getRemoteDevice(m_address)
                    m_bluetoothSocket = device.createInsecureRfcommSocketToServiceRecord(m_myUUID)
                    BluetoothAdapter.getDefaultAdapter().cancelDiscovery()
                    m_bluetoothSocket!!.connect()
                    Log.i(TAG,"success")
                }
            }catch (e: IOException){
                connectSuccess = false
                e.printStackTrace()
                Log.i(TAG,"not so much")
            }
            return null
        }

        override fun onPostExecute(result: String?) {
            super.onPostExecute(result)
            if(!connectSuccess){
                Log.i(TAG,"couldn't connect")
            } else{
                m_isConnected = true
            }
            m_progress.dismiss()
        }
    }

    private fun listen(){
        control_led_disconnect.setOnClickListener{disconnect()}
        seekBar.setOnSeekBarChangeListener(object: SeekBar.OnSeekBarChangeListener{

            override fun onProgressChanged(seekBar: SeekBar?, progress: Int, fromUser: Boolean) {
                s1.clawddata(progress)
            }

            override fun onStartTrackingTouch(seekBar: SeekBar?) {
            }

            override fun onStopTrackingTouch(seekBar: SeekBar?) {
                seekBar!!.progress = 50
            }
        })

        joystickView.setOnMoveListener { direction, strength ->
            result = 128 + (strength * sin(direction.toDouble() * PI / 180))

            result2 = if(result>128){
                128 - (strength * cos(direction.toDouble() * PI / 180))/1.5
            }else{
                128 + (strength * cos(direction.toDouble() * PI / 180))/1.5
            }
            s1.movementdata(result, result2)
        }
    }

    inner class Sender(var power:Int?,var direction: Int?,var claw:Int?) :Thread(){

        init {
            power= 128
            direction=128
            time=50
        }

        override fun run() {
            super.run()
            sendCommand(power.toString()+","+ direction.toString()+","+claw.toString()+"A")
        }

        fun power_dir(x:Double,y:Double){
            power = x.toInt();direction = y.toInt()
        }

        public fun time(x:Int){
            time = x
        }
        private fun sendCommand(input: String) {
            if (m_bluetoothSocket != null) {
                try {
                    m_bluetoothSocket!!.outputStream.write(input.toByteArray())
                    Log.i(TAG, input)
                } catch (e: IOException) {
                    e.printStackTrace()
                }
            }
        }
    }
}