package main

import (
	"beetai_lattepanda/file"
	"fmt"
	"io"

	//"log"
	"io/ioutil"
	"os"
	"os/exec"
	"strings"
	"time"

	//"path/filepath"
	"encoding/json"
	"strconv" // convert string to int
)

// scp -P 2224 -r -o 'ProxyJump dh.duyhai@ssh_tunnel.beetai.com' Check_engine admin@localhost:/admin/monitor/check/
var name_dir_engine string = ""
var state_read_ecf bool = false

// var path_base string = "/home/biface/monitor"
// var path_base = "/home/aibox/monitor"
var path_base = "/home/svr-bi-security/monitor"

// var path_base = "/home/ubuntu/monitor"

// var path_base = "/home/administrator/monitor"
// var path_base = "/home/adminars/monitor"

// var path_base string = "/home/admin/monitor"
var Path_base_engine string = path_base + "/engine/" + name_dir_engine //"count_people_face" // Name dir engine
var Path_log_engine string = path_base + "/log/log_engine"
var Path_log_luncher string = path_base + "/log/log_launcher"
var Path_engine_config string = path_base + "/setup/engine.json" // dia chi duoi file Config.txt
// var Path_config string = Path_base_engine + "/data/Config.txt"
var Path_config string = Path_base_engine + "/data/config.json"

// var path = "/admin/monitor/log/log_engine.txt"

//var time_sts int = 0
//var cam_sts int = 0

//var Path_config string = "/admin/monitor/face_recognition/data/Config.txt"

//engine
var engine_status int = 0

var Path_time string = path_base + "/setup/time_run.txt"
var time_start int = 0
var time_end int = 0
var time_start_defaut int = 5
var time_end_defaut int = 23
var Debug int = 1

var number_run int = 0 // Check so lan run lai engine khi engine loi

var message Message

type Message struct {
	Error_code int   `json:"error_code"`
	Data       Datas `json:"data"`
	SD_CARD    int   `json:"sd_card"`
}

// User struct which contains a name
// a type and a list of social links
type Datas struct {
	Box_id int `json:"box_id"`
	//Box_name string   `json:"box_name"`
	Engines []Engine `json:"engines"`
}

type Engine struct {
	IsConfig  string `json:"isConfig,omitempty"`
	Active    int    `json:"active"`
	Engine_id int    `json:"engine_id"`
	Id        int    `json:"id"`
	Link      string `json:"link"`
	Name      string `json:"name"`
	Path      string `json:"path"`
	Version   string `json:"version"`
	Time_run  string `json:"time_run,omitempty"`
}

//============================> Main <==========================

func main() {
	fmt.Println("------------------ Start --------------------")
	//GetDir() // Check thu muc
	fmt.Println("--------------------------")
	file.Check_path(Path_log_engine)
	file.Write_log("Begin Check, Restart program\n", Path_log_engine)
	fmt.Printf("Begin Check, Restart program\n")
	ReadEngineConfig(Path_engine_config) // Pharse engine.json to struct Message
	// Loop:
	for {
		fmt.Println("Path base:" + path_base)
		fmt.Println("-------------------- 0 ---------------------")
		//Check_dir_engine()                     // Check directory engine , Create Path_base engine
		// ReadTimeRun()
		//CheckCam()
		//CheckTime()
		ActionEngine()
		fmt.Println("-------------------- 1 ---------------------")
		Sleep_ms(5000)

	}
}

//========================> END MAIN <====================
//------------------ Function ----------------------------
// func Check_dir_engine() {
// 	if Debug == 1 {
// 		fmt.Println("Function Check_dir_engine ()")
// 	}

// 	name_dir_engine = strings.Replace(message.Data.Engines[0].Path, ".zip", "", -1)

// 	Path_base_engine = path_base + "/engine/" + name_dir_engine
// 	Path_config = Path_base_engine + "/data/Config.txt"
// 	Path_log_engine = path_base + "/log/log_engine"
// 	Path_log_luncher = path_base + "/log/log_launcher"
// 	Path_engine_config = path_base + "/setup/engine.json" // dia chi duoi file Config.txt
// 	Path_config = Path_base_engine + "/data/Config.txt"
// 	if Debug == 1 {
// 		fmt.Printf("Name_dir_engine :" + name_dir_engine + "\t")
// 		fmt.Println("Path_base_engine :" + Path_base_engine)
// 	}

// }

func GetDir() {
	if file.ReadFile("/admin/ver_sys.txt") == "1" {
		path_base = "/home/aibox/Documents/monitor"
	}
}
func ReadEngineConfig(path string) {
	if Debug == 1 {
		fmt.Println("Function ReadEngineConfig ()")
	}

	// Open our jsonFile
	jsonFile, err := os.Open(path)
	// if we os.Open returns an error then handle it
	if err != nil {
		fmt.Println(err)
		file.Write_log("ReadEngineConfig 1  () "+err.Error(), Path_log_engine)
	}
	if Debug == 1 {
		fmt.Println("Successfully Opened engine.json")
	}

	defer jsonFile.Close()

	byteValue, err := ioutil.ReadAll(jsonFile)
	if err != nil {
		fmt.Println(err)
		file.Write_log("ReadEngineConfig 2 () "+err.Error(), Path_log_engine)
	}
	json.Unmarshal(byteValue, &message)
	state_read_ecf = true

	file.Println("\nError_code: " + strconv.Itoa(message.Error_code))
	file.Println("Box_id: " + strconv.Itoa(message.Data.Box_id))
	// file.Println("---------------------------------------------")
	// List engine
	for i := 0; i < len(message.Data.Engines); i++ {
		file.Println("Isconfig: " + message.Data.Engines[i].IsConfig)
		file.Println("Active: " + strconv.Itoa(message.Data.Engines[i].Active))
		file.Println("Engine_id: " + strconv.Itoa(message.Data.Engines[i].Engine_id))
		file.Println("Id: " + strconv.Itoa(message.Data.Engines[i].Id))
		file.Println("Link: " + message.Data.Engines[i].Link)
		file.Println("Name: " + message.Data.Engines[i].Name)
		file.Println("Path: " + message.Data.Engines[i].Path)
		file.Println("Version: " + message.Data.Engines[i].Version)
		file.Println("Time_run: " + message.Data.Engines[i].Time_run)
		file.Println("---------------------------------------------")
	}
}

func ReadTimeRun(time string) (int, int) {
	var t_start int
	var t_end int
	if Debug == 1 {
		fmt.Println("Function ReadTimeRun ()")
	}
	// var value = message.Data.Engines[i].Time_run
	fmt.Println("\nTime_run:" + time)
	var list = strings.Split(time, ":")
	if Debug == 1 {
		fmt.Println(list)
		for i := 0; i < 2; i++ {
			fmt.Print(i)
			fmt.Print("_")
			fmt.Printf("%T", list[i])
			fmt.Print("_")
			fmt.Printf("%v\n", list[i])
		}
	}

	var x, _ = strconv.Atoi(list[0])
	t_start = x
	if t_start < 0 {
		t_start = 0
	} else if t_start > 23 {
		t_start = 23
	}
	var z, _ = strconv.Atoi(list[1])
	t_end = z
	if t_end < 0 {
		t_end = 0
	} else if t_end > 23 {
		t_end = 23
	}
	return t_start, t_end
}
func ActionEngine() {
	if Debug == 1 {
		fmt.Println("Function ActionEngine ()")
	}
	for i := 0; i < len(message.Data.Engines); i++ {
		var t_stt = CheckTime(message.Data.Engines[i].Time_run)
		//var cam_sts = CheckCam(message.Data.Engines[i].Path + "/data/Config.txt")
		var cam_sts = 1
		var enable, _ = strconv.Atoi(message.Data.Engines[i].IsConfig)
		if cam_sts*t_stt*enable == 1 {
			Status_engine()
			fmt.Println(" Setup Run Engine")
		} else {
			fmt.Println("Setup off Engine")

			if message.Data.Engines[i].Active == 1 {
				//var cmd string = "ps -A | grep " + message.Data.Engines[i].Name

				var cmd string = "pidof " + message.Data.Engines[i].Name
				out2, err := exec.Command("sh", "-c", cmd).Output()
				if err != nil {
					fmt.Println(err)
					//file.Write_log("ActionEngine () "+err.Error(), Path_log_engine)
				}
				fmt.Println("Lengh :"+cmd+"%v", len(out2))
				if len(out2) != 0 {
					// sudo kill $(pgrep FaceRecognition)

					//var cmd string = "sudo kill $(pgrep " + message.Data.Engines[i].Name + ")"
					//var cmd string = "pidof " + message.Data.Engines[i].Name
					var cmd string = "sudo kill -9 $(pidof " + message.Data.Engines[i].Name + ")"
					fmt.Println("CMD Kill_engine:" + cmd)
					_, err := exec.Command("sh", "-c", cmd).Output() //  kill $(pgrep FaceRecognition)
					//log.Fatal(err)
					if err != nil {
						file.Write_log("sudo kill engine of ActionEngine()  Error \n", Path_log_engine)
						fmt.Println("sudo kill engine of ActionEngine()  Error")
					}

				} else {
					fmt.Println("Engine kill")
				}
				out1, _ := exec.Command("sh", "-c", "ps -A | grep loop_run").Output()
				if len(out1) != 0 {
					_, err := exec.Command("sh", "-c", " sudo kill $(pgrep loop_run)").Output()
					if err != nil {
						file.Write_log("sudo kill $(pgrep loop_run) of CheckActionEngine() \n", Path_log_engine)
					}
					//log.Fatal(err)  sudo systemctl restart S905X_BI  rm /admin/monitor/launcher/S905X_BI
				} else {
					fmt.Println("loop_run kill")
				}
			} else {
				fmt.Println("Engine setting off on engine.json")
			}
		}
	}
}
func CheckTime(time_run string) int {
	var time_sts = 0
	if Debug == 1 {
		fmt.Println("Function CheckTime ()")
	}
	//ReadTimeRun(time string) (int, int)

	t_start, t_end := ReadTimeRun(time_run)
	var time_now = time.Now().Hour()
	if Debug == 1 {
		//fmt.Printf("Kieu time   : %T\n", time)
		fmt.Printf("time = %v\n", time_now)
	}
	if time_now >= t_start && time_now <= t_end {
		time_sts = 1
		//Status_engine()
		fmt.Println(" Time Engine's running")
	} else {
		time_sts = 0
	}
	return time_sts
}
func FloatToString(input_num float64) string {
	fmt.Println("Function FloatToString ()")
	// to convert a float number to a string
	return strconv.FormatFloat(input_num, 'f', 3, 64)
}
func KillLoopRun() {
	fmt.Println("Function KillLoopRun()")
	out1, err := exec.Command("sh", "-c", "ps -A | grep loop_run").Output()
	if err != nil {
		fmt.Println(err)
		file.Write_log("KillLoopRun() "+err.Error(), Path_log_engine)
	}
	if len(out1) != 0 {
		_, err := exec.Command("sh", "-c", "sudo kill $(pgrep loop_run)").Output() //  kill $(pgrep FaceRecognition)
		//log.Fatal(err)
		if err != nil {
			file.Write_log("sudo kill $(pgrep loop_run) of KillLoopRun() \n", Path_log_engine)
		}
		file.Write_log("KillLoopRun()\n", Path_log_engine)
		Sleep_ms(500)
	}
	fmt.Printf("Kill loop run and Run engine\n")

}
func Status_engine() {
	if Debug == 1 {
		fmt.Println("Function Status_engine ()")
	}
	for i := 0; i < len(message.Data.Engines); i++ {
		if message.Data.Engines[i].Active == 1 {
			//var cmd string = "ps -A | grep " + message.Data.Engines[i].Name
			var cmd string = "pidof " + message.Data.Engines[i].Name
			fmt.Println(cmd)
			//file.Write_log(cmd, Path_log_engine)
			out, err := exec.Command("sh", "-c", cmd).Output()
			fmt.Println(out)
			if err != nil {
				fmt.Println(err)
				file.Write_log("Status_engine () "+err.Error(), Path_log_engine)
			}
			if len(out) == 0 {
				fmt.Printf(message.Data.Engines[i].Name + "isn't running\n")
				file.Write_log(message.Data.Engines[i].Name+"isn't running\n", Path_log_engine)
				//KillLoopRun()
				RunEngine(message.Data.Engines[i].Name)
			} else {
				number_run = 0
				fmt.Printf(message.Data.Engines[i].Name + " is running\n")
			}
		} else {
			fmt.Println("Engine setting off on engine.json")
		}

	}
}

func CheckCam(path string) int {
	var cam_sts int
	if Debug == 1 {
		fmt.Println("Function CheckCam ()")
	}
	for i := 0; i < len(message.Data.Engines); i++ {
		var ip string = ""
		ip = GetIPCam(path)
		fmt.Println("Ip camera: " + ip)
		out, err := exec.Command("ping", ip, "-c 5", "-i 0.2", "-w 5").Output()
		if err != nil {
			fmt.Println(err)
			file.Write_log("CheckCam () "+err.Error(), Path_log_engine)
			cam_sts = 0
		} else {

		}
		if strings.Contains(string(out), "Destination Host Unreachable") {
			fmt.Println("Disconnect camera...")
			file.Write_log("Disconnect camera", Path_log_engine)
			cam_sts = 0
		} else {
			fmt.Println("Connected camera...")
			cam_sts = 1
		}

	}
	return cam_sts
	//fmt.Println("End Function CheckCam")
}

func GetIPCam(path string) string {
	if Debug == 1 {
		fmt.Println("Function GetIPCam ()")
	}

	var ip string = ""
	str := ReadFile(path)
	j := strings.Index(str, "@")
	if j > -1 {
		fmt.Println(j)
		index := str[j+1 : j+20]
		t := strings.Index(index, "@")
		if t > -1 {
			index := str[t+1 : t+15]
			fmt.Println(index)
			list_0 := strings.Split(index, ":")
			ip = list_0[0]
		} else {
			fmt.Println(index)
			list_0 := strings.Split(index, ":")
			ip = list_0[0]
		}

	} else {
		i := strings.Index(str, "192")

		//fmt.Println("Index: ", i)
		if i > -1 {
			if Debug == 1 {
				fmt.Println(str[i : i+15])
			}

			index := str[i : i+15]
			list := strings.Split(index, ".")
			//fmt.Println(list)
			k := strings.Index(list[3], "\n")
			if k > -1 {
				x := strings.Split(list[3], "\n")
				list[3] = x[0]
			} else {
				j := strings.Index(list[3], "/")
				if j > -1 {
					x := strings.Split(list[3], "/")
					list[3] = x[0]
				} else {
					t := strings.Index(list[3], ":")
					if t > -1 {
						x := strings.Split(list[3], ":")
						list[3] = x[0]
					}
				}
			}

			ip = list[0]
			for i := 1; i < 4; i++ {
				if Debug == 1 {
					fmt.Printf("%v_", list[i])
				}

				ip = ip + "." + list[i]
			}

		} else {
			file.Write_log("cam_id not found", Path_log_engine)
			fmt.Println("cam_id not found")
		}
	}
	return ip
}

func RunEngine(name string) {
	fmt.Println("Function RunEngine ()")
	number_run = number_run + 1
	if number_run > 25 {
		time.Sleep(10000)
		// RebootBox()
		number_run = 0
		file.Write_log(" Number run engine > 25 ----> reset count_number=0 && not reset ", Path_log_engine)
	} else {
		//while true; do /home/beetsoft/Desktop/face_recognition_20190308/build/FaceRecognition/FaceRecognition ;done
		// FaceRecognition/FaceRecognition ../data/Config.txt  > /dev/null 2>&1 &
		//var cmd = "cd " + path_base + "/engine/" + name + "/build/ && " + "screen -dm -S Engine " + name + "/" + name + " ../data/Config.txt  > /dev/null 2>&1 &"
		//var cmd = "export DISPLAY=:0&&cd " + path_base + "/engine/" + name + "/build/  " + "&& " + name + "/" + name + " ../data/config.json  > /dev/null 2>&1 &"
		var cmd = "export DISPLAY=:0&&cd " + path_base + "/engine/" + name + "/build/  " + "&& " + name + "/" + name + " ../data/Config.txt > /dev/null 2>&1 &"

		// var cmd = "cd " + path_base + "/engine/" + name + "/build/  " + "&& " + name + "/" + name + " ../data/config.json  > /dev/null 2>&1 &"
		if Debug == 1 {
			fmt.Println("cmd run engine", cmd)
		}
		out, err := exec.Command("sh", "-c", cmd).Output()
		if err != nil {
			//log.Fatal(err)
			engine_status = 1
			file.Write_log("RunEngine () "+err.Error(), Path_log_engine)
			fmt.Printf("RunEngine()  not run \n")
		} else {
			fmt.Printf("RunEngine()  ok \n")
			file.Write_log("RunEngine() ok \n", Path_log_engine)
			engine_status = 0
			var out1 = string(out)
			fmt.Printf(out1)
		}
	}

}
func RebootBox() {
	fmt.Println("Function RebootBox()")
	_, err := exec.Command("sh", "-c", "reboot").Output()
	if err == nil {
		file.Write_log("RebootBox()", Path_log_luncher)
	}
	fmt.Println("End Function RebootBox()")
}

func Sleep_ms(ms time.Duration) {
	time.Sleep(time.Millisecond * ms) // sleep(nano second)
}

// Thao tac file
func CreateLogfile(path string) {
	fmt.Println("Function CreateLogfile ()")
	// detect if file exists
	var _, err = os.Stat(path)

	// create file if not exists
	if os.IsNotExist(err) {
		var file, err = os.Create(path)
		if err != nil {
			fmt.Println(err)
			//file.Write_log("CreateLogfile() "+err.Error(), Path_log_engine)
		}
		defer file.Close()
	}

	fmt.Println("==> done creating file", path)
}

// func file.file.Write_log(msg string, path string) {
// 	fmt.Println("Function file.Write_log ()")
// 	// open file using READ & WRITE permission
// 	// fmt.Println("==>begin writting ")
// 	var file, err = os.OpenFile(path, os.O_RDWR|os.O_APPEND, 0777)
// 	if err != nil {
// 		fmt.Println(err)
// 		file.Write_log("file.Write_log 1 () "+err.Error(), Path_log_engine)
// 	}
// 	defer file.Close()

// 	_, err = file.WriteString(time.Now().String())
// 	if err != nil {
// 		fmt.Println(err)
// 		file.Write_log("file.Write_log 2 () "+err.Error(), Path_log_engine)
// 	}
// 	// write some text line-by-line to file
// 	_, err = file.WriteString("\n")
// 	if err != nil {
// 		fmt.Println(err)
// 		file.Write_log("file.Write_log 3 () "+err.Error(), Path_log_engine)
// 	}
// 	_, err = file.WriteString("Service Check_engine : " + msg)
// 	if err != nil {
// 		fmt.Println(err)
// 		file.Write_log("file.Write_log 4 () "+err.Error(), Path_log_engine)
// 	}
// 	_, err = file.WriteString("\n")
// 	if err != nil {
// 		fmt.Println(err)
// 		file.Write_log("file.Write_log 5 () "+err.Error(), Path_log_engine)
// 	}

// 	// save changes
// 	err = file.Sync()
// 	if err != nil {
// 		fmt.Println(err)
// 		file.Write_log("file.Write_log 6 () "+err.Error(), Path_log_engine)
// 	}

// 	//fmt.Println("==> done writing to file")
// }

// func readFile(path string) string {
// 	if Debug == 1 {
// 		fmt.Println("Function readFile ()")
// 	}

// 	// re-open file
// 	var msg string = ""
// 	var file, err = os.OpenFile(path, os.O_RDWR, 0644)
// 	if err != nil {
// 		//file.Write_log("readFile 1 () "+err.Error(), Path_log_engine)
// 		time_start = time_start_defaut
// 		time_end = time_end_defaut
// 	} else {
// 		defer file.Close()
// 		// read file, line by line
// 		var text = make([]byte, 1024)
// 		for {
// 			_, err = file.Read(text)
// 			// break if finally arrived at end of file
// 			if err == io.EOF {
// 				//file.Write_log("readFile 2() "+err.Error(), Path_log_engine)
// 				//break

// 			}

// 			// break if error occured
// 			if err != nil && err != io.EOF {
// 				//file.Write_log("readFile 3() "+err.Error(), Path_log_engine)
// 				//break
// 			}
// 		}
// 		//fmt.Println(string(text))
// 		msg = string(text)
// 	}
// 	fmt.Println(time_start)
// 	fmt.Println(time_end)
// 	fmt.Println("read file done")
// 	return msg
// }

func DeleteFile(path string) {
	fmt.Println("Function DeleteFile ()")
	// delete file
	var err = os.Remove(path)
	if err != nil {
		fmt.Println(err)
		file.Write_log("DeleteFile () "+err.Error(), Path_log_engine)
	}

	fmt.Println("==> done deleting file")
}

func IsError(err error) bool {
	//fmt.Println("Function IsError ()")
	if err != nil {
		fmt.Println(err.Error())
	}

	return (err != nil)
}

func ReadFile(path string) string {
	if Debug == 1 {
		fmt.Println("Function ReadFile ()")
	}

	// re-open file
	var msg string = ""
	var file, err = os.OpenFile(path, os.O_RDWR, 0644)
	if err != nil {
		fmt.Println(" Open file error")
		//file.Write_log("ReadFile 1 () "+err.Error(), Path_log_engine)

	}
	defer file.Close()
	// read file, line by line
	var text = make([]byte, 2048)
	for {
		_, err = file.Read(text)
		// break if finally arrived at end of file
		if err == io.EOF {
			//file.Write_log("ReadFile 2 () "+err.Error(), Path_log_engine)
			break
		}

		// break if error occured
		if err != nil && err != io.EOF {
			//file.Write_log("ReadFile 3 () "+err.Error(), Path_log_engine)
			break
		}
	}
	msg = string(text)
	//fmt.Println(msg)
	return msg
}