package zdaemon

import (
	"fmt"
	"git.swzry.com/zry/SatorIPC/golang/sipc_conn"
	"github.com/gin-gonic/gin"
	"gopkg.in/natefinch/lumberjack.v2"
	"net/http"
	"os"
	"path"
	"sync"
	"time"
)

const TimeFormatLayout = "2006-01-02 15:04:05"

func (zd *ZDaemon) directRun() {
	if zd.checkRunning() {
		zd.stop()
	}
	logger := &lumberjack.Logger{
		Filename:   path.Join(zd.zdaemonPath, "local.log"),
		MaxSize:    1,
		MaxAge:     30,
		MaxBackups: 24,
		LocalTime:  true,
		Compress:   true,
	}
	zd.webserver = gin.Default()
	zd.webserver.GET("/", zd.webHome)
	zd.webserver.GET("/check-alive.satori", zd.webCheckAlive)
	zd.webserver.GET("/stop.satori", zd.webStop)
	zd.webserver.GET("/status.satori", zd.webStatus)
	zd.webserver.POST("/other-operation.satori", zd.webOtherOp)
	zd.cleanIPCUnixSock()
	zd.makeIPCDir()
	ipcaddr := sipc_conn.GenerateCustomPath(path.Join(zd.zdaemonPath, "ipc"), sipc_conn.GenerateServerName())
	var err error
	zd.ipcserver, err = sipc_conn.NewServer(ipcaddr, false)
	if err != nil {
		_, _ = fmt.Fprintln(logger, "Failed create IPC server: ", err.Error())
		return
	}
	zd.daemonProgram = zd.initFunc()
	zd.daemonProgram.SetLocalLogWriter(logger)
	zd.ipcserver.SetConnErrorHandler(func(err error) {
		_, _ = fmt.Fprintln(logger, "Wrong IPC Connection: ", err.Error())
	})
	zd.ipclistener, err = zd.ipcserver.GetListenerAndListen()
	if err != nil {
		_, _ = fmt.Fprintln(logger, "Failed create IPC server: ", err.Error())
		return
	}
	zd.daemonConfig.IsRunning = true
	zd.daemonConfig.PID = os.Getpid()
	zd.daemonConfig.IpcAddr = ipcaddr
	zd.writeStatus()
	var wg sync.WaitGroup
	wg.Add(2)
	go func() {
		err := http.Serve(zd.ipclistener, zd.webserver)
		if err != nil {
			_, _ = fmt.Fprintln(logger, "Error in IPC server listening: ", err.Error())
		}
		wg.Done()
	}()
	go func() {
		err := zd.daemonProgram.Start()
		if err != nil {
			_, _ = fmt.Fprintln(logger, "Error in daemon running: ", err.Error())
		}
		wg.Done()
	}()
	wg.Wait()
	_, _ = fmt.Fprintln(logger, "Both IPC server and user program end. Daemon program quit.")
}

func (zd *ZDaemon) webHome(ctx *gin.Context) {
	ctx.JSON(200, gin.H{
		"zdaemon_version": "1.0",
		"daemon_name":     zd.daemonName,
	})
}

func (zd *ZDaemon) webCheckAlive(ctx *gin.Context) {
	al := &IPCJsonDef_CheckAlive{Alive: true}
	ctx.JSON(200, al)
}

func (zd *ZDaemon) webStop(ctx *gin.Context) {
	if zd.daemonProgram == nil {
		al := &IPCJsonDef_Stop{
			Success: false,
			Msg:     "daemon program instance is null pointer.",
		}
		ctx.JSON(200, al)
		return
	}
	var al *IPCJsonDef_Stop
	if zd.daemonProgram != nil {
		err := zd.daemonProgram.Stop()
		if err != nil {
			al = &IPCJsonDef_Stop{
				Success: false,
				Msg:     err.Error(),
			}
		} else {
			al = &IPCJsonDef_Stop{
				Success: true,
				Msg:     "None",
			}
		}
	} else {
		al = &IPCJsonDef_Stop{
			Success: false,
			Msg:     "daemon program instance is null pointer",
		}
	}
	ctx.JSON(200, al)
	go func() {
		time.Sleep(time.Second)
		if zd.ipclistener != nil {
			_ = zd.ipclistener.Close()
			os.Exit(0)
		}
	}()
}

func (zd *ZDaemon) webStatus(ctx *gin.Context) {
	if zd.daemonProgram == nil {
		al := &IPCJsonDef_GetStatus{
			Status:   "error",
			HasExtra: false,
			ExtraInfo: map[string]string{
				"errmsg": "daemon program instance is null pointer.",
			},
		}
		ctx.JSON(200, al)
		return
	}
	st, he, ex := zd.daemonProgram.GetStatus()
	al := &IPCJsonDef_GetStatus{
		Status:    st,
		HasExtra:  he,
		ExtraInfo: ex,
	}
	ctx.JSON(200, al)
}

func (zd *ZDaemon) webOtherOp(ctx *gin.Context) {
	if zd.daemonProgram == nil {
		al := &IPCJsonDef_OtherOperationResponse{
			Result: "Error: daemon program instance is null pointer.",
		}
		ctx.JSON(200, al)
		return
	}
	var jv IPCJsonDef_OtherOperationRequest
	err := ctx.BindJSON(&jv)
	if err != nil {
		al := &IPCJsonDef_OtherOperationResponse{
			Result: fmt.Sprint("Error: ", err.Error()),
		}
		ctx.JSON(200, al)
		return
	}
	st := zd.daemonProgram.OtherOperation(jv.Operation, jv.Args)
	al := &IPCJsonDef_OtherOperationResponse{
		Result: st,
	}
	ctx.JSON(200, al)
}