package app

import (
	"my/go-controller/analog"
	"my/go-controller/digital"
	"my/go-controller/serial"
	"my/go-controller/task"
	"my/go-controller/timer"
)

const VREMYA_SVETA uint32 = 20000

var loopBlockTime task.TickType = task.MS_TO_TICKS(1000)
var vklYarkBlockTime task.TickType = task.MS_TO_TICKS(10)
var vyklYarkBlockTime task.TickType = task.MS_TO_TICKS(50)

var vkl bool
var kogdaVyklyuchit uint32

func initSvet() {
	vkl = false
	kogdaVyklyuchit = 0

	Vyklyuchit()
}

func DvizhEst(start int) {
	kogdaVyklyuchit = timer.Millis() + VREMYA_SVETA

	if !vkl {
		vkl = true
		if DEBUG {
			serial.Println("Vkl svet")
		}
		PlavnoVklyuchit(start)
	}
}
func DvizhaNet() {
	if kogdaVyklyuchit > timer.Millis() {
		return
	}

	if vkl {
		vkl = false
		if DEBUG {
			serial.Println("Vykl")
		}
		PlavnoVyklyuchit()
	}
}

func PlavnoVklyuchit(start int) {
	digital.Write(SVET_ONOFF_PIN, 1)

	var i int
	for i = start; i >= 0; i-- {
		analog.Write(SVET_YARK_PIN, i)
		if DEBUG {
			serial.Println(i)
		}
		timer.Delay(5)
	}

	Vklyuchit()
}
func PlavnoVyklyuchit() {
	var v int
	var i int
	for i = 0; i <= 255; i++ {
		analog.Write(SVET_YARK_PIN, i)
		if DEBUG {
			serial.Println(i)
		}

		v = task.TaskNotifyTake(0, vyklYarkBlockTime)
		if v > 0 {
			DvizhEst(i)
			return
		}
	}
	Vyklyuchit()
}

func Vklyuchit() {
	digital.Write(SVET_YARK_PIN, 0) // логика яркости инвертирована
	digital.Write(SVET_ONOFF_PIN, 1)
}
func Vyklyuchit() {
	digital.Write(SVET_YARK_PIN, 1) // логика яркости инвертирована
	digital.Write(SVET_ONOFF_PIN, 0)
}

func TaskSveta() {
	var v int

	for {
		/* Block to wait for a notification.  Here the RTOS
		   task notification is being used as a counting semaphore.
		   The task's notification value is incremented each time
		   the ISR calls vTaskNotifyGiveFromISR(), and decremented
		   each time the RTOS task calls ulTaskNotifyTake() - so in
		   effect holds a count of the number of outstanding interrupts.
		   The first parameter is set to pdFALSE, so the notification
		   value is only decremented and not cleared to zero, and one
		   deferred interrupt event is processed at a time. */
		v = task.TaskNotifyTake(0, loopBlockTime)
		if v > 0 {
			DvizhEst(255)
		} else {
			DvizhaNet()
		}
	}
}