package main

import (
	"fmt"
	"gitea.unprism.ru/KRBL/n9m"
	"net"
	"os"
)

func main() {
	ln, err := net.Listen("tcp", "0.0.0.0:5556")

	if err != nil {
		panic(err)
	}

	for {
		var conn net.Conn

		conn, err = ln.Accept()

		if err != nil {
			continue
		}

		go handle(conn)
	}
}

func handle(conn net.Conn) {
	var err error
	var rn int

	var serial string

	packS := n9m.Package{}
	tmp := make([]byte, 1024)

	for {
		rn, err = conn.Read(tmp)

		if err != nil {
			fmt.Println(err)
			return
		}

		packS.AddToAccum(tmp[:rn])

		for packS.ReadPackage() {
			switch packS.PayloadType {
			case n9m.PayloadTypeData:
				combined := packS.Payload.Module + ":" + packS.Payload.Operation

				switch combined {
				case "CERTIFICATE:CONNECT":
					var params n9m.CertificateConnectRequest

					if err = packS.GetParametersAs(&params); err != nil {
						fmt.Println(combined, err)
						return
					}

					var response = n9m.CertificateConnectResponse{
						ErrorCode:   0,
						CommandMask: n9m.CommandMaskAll,
					}

					packS.SetResponse(response)

					if _, err = conn.Write(packS.PackPackage()); err != nil {
						fmt.Println(combined, err)
						return
					}

					fmt.Println("Connected:", params.SerialNumber)
					serial = params.SerialNumber

					var request n9m.ConfigModelGetRequest
					request.MDVR = "?"
					packS.Payload.Module = "CONFIGMODEL"
					packS.Payload.Operation = "GET"
					packS.SetParameters(request)

					conn.Write(packS.PackPackage())

					/*
						go func() {
							pack := packS
							pack.Payload.Module = "EVEM"
							pack.Payload.Operation = "GALARMING"

							ticker := time.NewTicker(5 * time.Second)
							defer ticker.Stop()

							for range ticker.C {
								fmt.Println("Sent!")
								if _, err := conn.Write(pack.PackPackage()); err != nil {
									fmt.Println("Failed to send GALARMING:", err)
									return
								}
							}
						}()
					*/
				case "CERTIFICATE:KEEPALIVE":
					packS.SetResponse(nil)
					if _, err = conn.Write(packS.PackPackage()); err != nil {
						fmt.Println(combined, err)
						return
					}

					fmt.Println("Connection is still alive!")
				case "EVEM:GGALARMING":
					fmt.Println(string(packS.RawPayload))

					var response n9m.EventModelGetAlarmingResponse
					if err = packS.GetResponseAs(&response); err != nil {
						fmt.Println(combined, err)
						continue
					}

					fmt.Printf("%+v\n", response)
				case "CONFIGMODEL:GET":
					os.WriteFile(fmt.Sprintf("./%s.json", serial), packS.RawPayload, 0644)
				case "EVEM:SENDALARMINFO":
					var params n9m.SendAlarmInfoParameters
					var response n9m.SendAlarmInfoResponse

					if err = packS.GetParametersAs(&params); err != nil {
						fmt.Printf("Error: %s\nData: %s", err, packS.RawPayload)
						continue
					}

					response.ErrorCode = 0
					response.AlarmType = params.AlarmType
					response.CommandType = params.CommandType
					response.AlarmUID = params.AlarmUID
					response.NumberOfRestarts = params.NumberOfRestarts
					response.InstructionSerial = params.InstructionSerial

					switch params.AlarmType {
					case n9m.AlarmTypeMotionDetection:
						break
					case n9m.AlarmTypeVideoLoss, n9m.AlarmTypeCameraCovered:
						var cameraParams n9m.SendAlarmInfoCameraParameters

						if err = packS.GetParametersAs(&cameraParams); err != nil {
							fmt.Printf("Error: %s\nData: %s", err, packS.RawPayload)
							continue
						}

						fmt.Printf("%+v\n", cameraParams)

						packS.SetResponse(response)
						conn.Write(packS.PackPackage())
					default:
						fmt.Println("Unknown alarm type:", params.AlarmType)
					}
				default:
					fmt.Println("Strange operation:", combined)
				}

			case n9m.PayloadTypeSpecial:
				switch packS.SSRC {
				case n9m.SpecialPayloadTypeGPS:
					fmt.Printf("%+v\n", packS.GPS)
				default:
					fmt.Println("Unhandled special operation:", packS.SSRC)
				}
			default:
				fmt.Println("Unhandled operation:", packS.PayloadType)
			}
		}
	}
}