package controllers

import (
	"basic.com/valib/bhomeclient.git"
	"encoding/json"
	"strings"
	"time"
	"vamicro/log-service/models"
)

type LogServiceController struct {
	bk bhomeclient.Broker
}

func (ac LogServiceController) FindAllMap(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	var module models.Modules
	allmap := module.FindAllMap()

	return &bhomeclient.Reply{Success: true, Data: allmap}
}

func (ac LogServiceController) SetModules(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	var params []models.Modules
	if err := c.BindJSON(&params); err != nil {
		return &bhomeclient.Reply{Success: false, Msg: "参数格式错误,非法的json格式"}
	}
	for _, item := range params {
		item.Insert()
	}
	return &bhomeclient.Reply{Success: true, Data: params}
}

func (ac LogServiceController) SetOperations(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	var params []models.Operations
	if err := c.BindJSON(&params); err != nil {
		return &bhomeclient.Reply{Success: false, Msg: "参数格式错误,非法的json格式"}
	}
	for _, item := range params {
		item.Insert()
	}
	return &bhomeclient.Reply{Success: true, Data: params}
}

func (ac LogServiceController) Modules(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	var moduleMod models.Modules
	modules, err := moduleMod.FindAll()
	if nil == err {
		return &bhomeclient.Reply{Success: true, Data: modules}
	} else {
		return &bhomeclient.Reply{Success: true, Data: make([]interface{}, 0)}
	}
}

func (ac LogServiceController) Operations(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	var opModel models.Operations
	module := c.Query("module")
	opers, err := opModel.FindAll(module)
	if nil == err {
		return &bhomeclient.Reply{Success: true, Data: opers}
	} else {
		return &bhomeclient.Reply{Success: false, Msg: err.Error()}
	}
}

func (ac LogServiceController) OperationLog(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	var params models.OperationQuery
	if err := c.BindJSON(&params); err != nil {
		return &bhomeclient.Reply{Success: false, Msg: "参数格式错误,非法的json格式"}
	}

	var tsStart, tsEnd time.Time
	if params.TimeStart == "" && params.TimeEnd == "" {
		tsEnd = time.Now()
		tsStart = tsEnd.Add(-time.Hour * 24)
	} else if params.TimeStart == "" && params.TimeEnd != "" {
		ts, ok := checkTime(params.TimeEnd)
		if !ok {
			return &bhomeclient.Reply{Success: false, Msg: "参数有误，时间解析错误"}
		}
		tsEnd = ts
		tsStart = tsEnd.Add(-time.Hour * 24 * 365)
	} else if params.TimeStart != "" && params.TimeEnd == "" {
		ts, ok := checkTime(params.TimeStart)
		if !ok {
			return &bhomeclient.Reply{Success: false, Msg: "参数有误，时间解析错误"}
		}

		tsStart = ts
		tsEnd = time.Now()
	} else {
		var ok bool
		tsStart, ok = checkTime(params.TimeStart)
		if !ok {
			return &bhomeclient.Reply{Success: false, Msg: "参数有误，时间解析错误"}
		}

		tsEnd, ok = checkTime(params.TimeEnd)
		if !ok {
			return &bhomeclient.Reply{Success: false, Msg: "参数有误，时间解析错误"}
		}

		if tsStart.After(tsEnd) {
			return &bhomeclient.Reply{Success: false, Msg: "参数有误, 开始时间大于结束时间"}
		}
	}

	db := models.GetDB()
	db = db.Where("timestamp >= ? AND timestamp <= ?", tsStart.Unix(), tsEnd.Unix())
	if params.Module != "" {
		db = db.Where("module = ?", params.Module)
	}

	if params.Function != "" {
		db = db.Where("function = ?", params.Function)
	}

	if params.Result != "" {
		db = db.Where("result = ?", params.Result)
	}

	if params.FuzzySearch != "" {
		db = db.Where("para like ? or userName like ? or function like ?",
			"%"+params.FuzzySearch+"%",
			"%"+params.FuzzySearch+"%",
			"%"+params.FuzzySearch+"%")
	}

	if params.Page <= 0 {
		params.Page = 1
	}
	var count int64 = 0
	err := db.Table("t_op_log").Count(&count).Error
	if nil != err {
		return &bhomeclient.Reply{Success: false, Msg: "内部错误" + err.Error()}
	}
	var logs []*models.OperationLog
	if result := db.Table("t_op_log").Limit(params.PageSize).Offset((params.Page - 1) * params.PageSize).Order("timestamp DESC").Find(&logs); nil != result.Error {
		return &bhomeclient.Reply{Success: false, Msg: "内部错误" + result.Error.Error()}
	}

	return &bhomeclient.Reply{Success: true, Data: map[string]interface{}{"logs": logs, "total": count}}
}

func (ac LogServiceController) ScheduleLog(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	var params models.ScheduleQuery
	if err := c.BindJSON(&params); err != nil {
		return &bhomeclient.Reply{Success: false, Msg: "参数格式错误,非法的json格式"}
	}

	var tsStart, tsEnd time.Time
	if params.TimeStart == "" && params.TimeEnd == "" {
		tsEnd = time.Now()
		tsStart = tsEnd.Add(-time.Hour * 24)
	} else if params.TimeStart == "" && params.TimeEnd != "" {
		ts, ok := checkTime(params.TimeEnd)
		if !ok {
			return &bhomeclient.Reply{Success: false, Msg: "参数有误，时间解析错误"}
		}
		tsEnd = ts
		tsStart = tsEnd.Add(-time.Hour * 24)
	} else if params.TimeStart != "" && params.TimeEnd == "" {
		ts, ok := checkTime(params.TimeStart)
		if !ok {
			return &bhomeclient.Reply{Success: false, Msg: "参数有误，时间解析错误"}
		}

		tsStart = ts
		tsEnd = tsStart.Add(time.Hour * 24)
	} else {
		var ok bool
		tsStart, ok = checkTime(params.TimeStart)
		if !ok {
			return &bhomeclient.Reply{Success: false, Msg: "参数有误，时间解析错误"}
		}

		tsEnd, ok = checkTime(params.TimeEnd)
		if !ok {
			return &bhomeclient.Reply{Success: false, Msg: "参数有误，时间解析错误"}
		}

		if tsStart.After(tsEnd) {
			return &bhomeclient.Reply{Success: false, Msg: "参数有误, 开始时间大于结束时间"}
		}
	}

	db := models.GetDB()
	db = db.Where("timestamp >= ? AND timestamp <= ?", tsStart.Unix(), tsEnd.Unix())
	if params.ProcID != "" {
		procIds := strings.Split(params.ProcID, ",")
		db = db.Where("procID in (?)", procIds)
	}

	if params.ProcName != "" {
		db = db.Where("procName like ?", params.ProcName)
	}

	if params.FuzzySearch != "" {
		db = db.Where("info like ?", "%"+params.FuzzySearch+"%")
	}

	if params.Page <= 0 {
		params.Page = 1
	}
	var count int64 = 0
	err := db.Table("t_schedule_log").Count(&count).Error
	if nil != err {
		return &bhomeclient.Reply{Success: false, Msg: "内部错误" + err.Error()}
	}
	var logs []*models.ScheduleLog
	if result := db.Table("t_schedule_log").Limit(params.PageSize).Offset((params.Page - 1) * params.PageSize).Find(&logs); nil != result.Error {
		return &bhomeclient.Reply{Success: false, Msg: "内部错误" + result.Error.Error()}
	}

	data := make([]map[string]interface{}, 0)

	if len(logs) > 0 {
		for _, item := range logs {
			dd := make(map[string]interface{}, 0)
			l, _ := json.Marshal(item)
			json.Unmarshal(l, &dd)
			dd["addTime"] = time.Unix(item.Timestamp, 0).Format("2006-01-02 15:04:05")
			dd["minute"] = 0
			t, err := time.ParseInLocation("2006-01-02 15:04:05", item.ScheduleStartTime, time.Local)
			if nil == err {
				t2, err := time.ParseInLocation("2006-01-02 15:04:05", item.ScheduleEndTime, time.Local)
				if err == nil {
					dd["minute"] = (t2.Unix() - t.Unix()) / 60
				}
			}

			data = append(data, dd)
		}
	}
	return &bhomeclient.Reply{Success: true, Data: map[string]interface{}{"logs": data, "total": count}}
}

func (ac LogServiceController) RuleServerLog(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	var params models.RuleServerLogQuery
	if err := c.BindJSON(&params); err != nil {
		return &bhomeclient.Reply{Success: false, Msg: "参数格式错误,非法的json格式"}
	}

	db := models.GetDB()
	if params.TimeStart != "" {
		db = db.Where("lastSendDate >= ?", params.TimeStart)
	}
	if params.TimeEnd != "" {
		db = db.Where("lastSendDate <= ?", params.TimeEnd)
	}
	if params.TaskName != "" {
		db = db.Where("name like ?", params.TaskName)
	}

	if params.State != "" {
		db = db.Where("state like ?", params.State)
	}

	if params.FuzzySearch != "" {
		db = db.Where("name like ? ", "%"+params.FuzzySearch+"%")
	}

	if params.Page <= 0 {
		params.Page = 1
	}
	var count int64 = 0
	err := db.Table("t_rule_server_log").Count(&count).Error
	if nil != err {
		return &bhomeclient.Reply{Success: false, Msg: "内部错误" + err.Error()}
	}
	var logs []*models.RuleServerLog
	if result := db.Table("t_rule_server_log").Limit(params.PageSize).Offset((params.Page - 1) * params.PageSize).Find(&logs); nil != result.Error {
		return &bhomeclient.Reply{Success: false, Msg: "内部错误" + result.Error.Error()}
	}

	return &bhomeclient.Reply{Success: true, Data: map[string]interface{}{"logs": logs, "total": count}}
}

func (ac LogServiceController) VaSystemLog(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	var params models.VaSystemQuery
	if err := c.BindJSON(&params); err != nil {
		return &bhomeclient.Reply{Success: false, Msg: "参数格式错误,非法的json格式"}
	}

	var tsStart, tsEnd time.Time
	if params.TimeStart == "" && params.TimeEnd == "" {
		tsEnd = time.Now()
		tsStart = tsEnd.Add(-time.Hour * 24)
	} else if params.TimeStart == "" && params.TimeEnd != "" {
		ts, ok := checkTime(params.TimeEnd)
		if !ok {
			return &bhomeclient.Reply{Success: false, Msg: "参数有误，时间解析错误"}
		}
		tsEnd = ts
		tsStart = tsEnd.Add(-time.Hour * 24)
	} else if params.TimeStart != "" && params.TimeEnd == "" {
		ts, ok := checkTime(params.TimeStart)
		if !ok {
			return &bhomeclient.Reply{Success: false, Msg: "参数有误，时间解析错误"}
		}

		tsStart = ts
		tsEnd = tsStart.Add(time.Hour * 24)
	} else {
		var ok bool
		tsStart, ok = checkTime(params.TimeStart)
		if !ok {
			return &bhomeclient.Reply{Success: false, Msg: "参数有误，时间解析错误"}
		}

		tsEnd, ok = checkTime(params.TimeEnd)
		if !ok {
			return &bhomeclient.Reply{Success: false, Msg: "参数有误，时间解析错误"}
		}

		if tsStart.After(tsEnd) {
			return &bhomeclient.Reply{Success: false, Msg: "参数有误, 开始时间大于结束时间"}
		}
	}

	db := models.GetDB()
	db = db.Where("timestamp >= ? AND timestamp <= ?", tsStart.Unix(), tsEnd.Unix())
	if len(params.ProcName) > 0 {
		db = db.Where("procName in (?)", params.ProcName)
	}

	if params.Level != 0 {
		db = db.Where("level = (?)", params.Level)
	}

	if params.FuzzySearch != "" {
		db = db.Where("address like ? or info like ? or procName like ?",
			"%"+params.FuzzySearch+"%",
			"%"+params.FuzzySearch+"%",
			"%"+params.FuzzySearch+"%")
	}

	if params.Page <= 0 {
		params.Page = 1
	}

	var count int64 = 0
	tableName := models.VaSystemLog{}.TableName()

	err := db.Table(tableName).Count(&count).Error
	if nil != err {
		return &bhomeclient.Reply{Success: false, Msg: "内部错误" + err.Error()}
	}

	var logs []*models.VaSystemLog
	if result := db.Table(tableName).Limit(params.PageSize).Offset((params.Page - 1) * params.PageSize).Order("timestamp DESC").Find(&logs); nil != result.Error {
		return &bhomeclient.Reply{Success: false, Msg: "内部错误" + result.Error.Error()}
	}

	return &bhomeclient.Reply{Success: true, Data: map[string]interface{}{"logs": logs, "total": count}}
}

func (ac LogServiceController) GetProcNames(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	logs := []models.VaSystemLog{}
	procs := []string{}

	tableName := models.VaSystemLog{}.TableName()
	models.GetDB().Table(tableName).Group("procName").Select("procName").Find(&logs).Pluck("procName", &procs)

	return &bhomeclient.Reply{Success: true, Data: procs}
}

func checkTime(dateTime string) (time.Time, bool) {
	ts, err := time.ParseInLocation("2006-01-02 15:04:05", dateTime, time.Local)
	if err != nil {
		return ts, false
	}

	return ts, true
}