package service

import (
	"errors"
	"fmt"
	"github.com/google/uuid"
	"gitlab.wodcloud.com/smart-operation/so-operation-api/src/bean/entity"
	"gitlab.wodcloud.com/smart-operation/so-operation-api/src/bean/vo/request"
	"gitlab.wodcloud.com/smart-operation/so-operation-api/src/bean/vo/response"
	"gitlab.wodcloud.com/smart-operation/so-operation-api/src/common/client"
	"gitlab.wodcloud.com/smart-operation/so-operation-api/src/pkg/beagle/resp"
	"os/exec"
	"strings"
	"time"
)

type HostManageSvc struct {
	User *entity.SystemUser
}

// AddHostManage 新增主机
func (h *HostManageSvc) AddHostManage(req request.AddHostManageReq) (err error) {
	db, err := client.GetDbClient()
	if err != nil {
		err = resp.DbConnectError.WithError(err)
		return
	}

	// 开启事务
	session := db.NewSession()
	defer session.Close()
	session.Begin()

	// 校验 主机分组名称 是否重复
	has, err := session.Table("host_manage").Where("is_delete = 0 AND host_name = ?", req.HostName).Exist()
	if has {
		err = resp.DbDataCheckError.WithError(errors.New("主机名称重复"))
		session.Rollback()
		return
	}
	if err != nil {
		err = resp.DbSelectError.WithError(err)
		session.Rollback()
		return
	}

	//新增主机分组
	hostManage := entity.HostManage{
		HostName:   req.HostName,
		CreateUser: "",
		CreateTime: time.Now(),
		UpdateUser: "",
		UpdateTime: time.Now(),
	}
	_, err = session.Table("host_manage").Insert(&hostManage)
	if err != nil {
		err = resp.DbInsertError.WithError(err)
		session.Rollback()
		return
	}

	//新增主机分组列表
	for _, v := range req.HostManageList {
		port := "22"
		if v.Port != "" {
			port = v.Port
		}
		hostManageList := entity.HostManageList{
			Ip:          v.Ip,
			Port:        port,
			VoucherType: v.VoucherType,
			UserName:    v.UserName,
			Password:    v.Password,
			HostGroupId: hostManage.Id,
			HostFileUrl: req.HostFileUrl,
			IpGroup:     v.IpGroup,
		}
		_, err = session.Table("host_manage_list").Insert(&hostManageList)
		if err != nil {
			err = resp.DbInsertError.WithError(err)
			session.Rollback()
			return
		}
	}

	session.Commit()
	return
}

// EditHostManage 编辑
func (h *HostManageSvc) EditHostManage(req request.EditHostManageReq) (err error) {
	db, err := client.GetDbClient()
	if err != nil {
		err = resp.DbConnectError.WithError(err)
		return
	}

	// 开启事务
	session := db.NewSession()
	defer session.Close()
	session.Begin()

	//修改主机分组信息
	hostManage := entity.HostManage{
		UpdateUser: "",
		UpdateTime: time.Now(),
	}
	_, err = session.Table("host_manage").Where("is_delete = 0 AND id = ?", req.Id).
		Cols("update_user,update_time").Update(&hostManage)
	if err != nil {
		err = resp.DbUpdateError.WithError(err)
		session.Rollback()
		return
	}

	//删除主机列表数据
	_, err = session.Table("host_manage_list").Where("host_group_id = ?", req.Id).Cols("is_delete").Update(&entity.TaskManage{
		IsDelete: 1,
	})
	if err != nil {
		err = resp.DbDeleteError.WithError(err)
		session.Rollback()
		return
	}

	//新增主机分组列表
	for _, v := range req.HostManageList {
		port := "22"
		if v.Port != "" {
			port = v.Port
		}
		hostManageList := entity.HostManageList{
			Ip:          v.Ip,
			Port:        port,
			VoucherType: v.VoucherType,
			UserName:    v.UserName,
			Password:    v.Password,
			HostGroupId: hostManage.Id,
			HostFileUrl: req.HostFileUrl,
			IpGroup:     v.IpGroup,
		}
		_, err = session.Table("host_manage_list").Insert(&hostManageList)
		if err != nil {
			err = resp.DbInsertError.WithError(err)
			session.Rollback()
			return
		}
	}

	session.Commit()
	return
}

// DelHostManage 删除任务
func (h *HostManageSvc) DelHostManage(req request.DelHostManageReq) (err error) {
	db, err := client.GetDbClient()
	if err != nil {
		err = resp.DbConnectError.WithError(err)
		return
	}

	// 开启事务
	session := db.NewSession()
	defer session.Close()
	session.Begin()

	//检测是否可删除
	var taskCnt int
	_, err = session.Table("task_manage").In("host_group_id", req.Id).
		Where("is_delete = 0").Select("count(*) AS task_cnt").Get(&taskCnt)
	if taskCnt > 0 {
		err = resp.DbDeleteError.WithError(errors.New("此主机分组下有关联任务，不可删除"))
		session.Rollback()
		return
	}
	if err != nil {
		err = resp.DbSelectError.WithError(err)
		session.Rollback()
		return
	}

	//删除主机分组
	_, err = session.Table("host_manage").In("id", req.Id).Cols("is_delete").Update(&entity.HostManageList{
		IsDelete: 1,
	})
	if err != nil {
		err = resp.DbDeleteError.WithError(err)
		session.Rollback()
		return
	}
	//删除主机分组列表
	_, err = session.Table("host_manage_list").In("host_group_id", req.Id).Cols("is_delete").Update(&entity.HostManageList{
		IsDelete: 1,
	})
	if err != nil {
		err = resp.DbDeleteError.WithError(err)
		session.Rollback()
		return
	}
	session.Commit()
	return
}

// DetailsHostManage 详情
func (h *HostManageSvc) DetailsHostManage(id int) (hostManageRes response.HostManageRes, err error) {
	db, err := client.GetDbClient()
	if err != nil {
		err = resp.DbConnectError.WithError(err)
		return
	}

	var hostManage response.HostManage
	hostList := make([]response.HostList, 0)
	taskList := make([]response.TaskList, 0)

	//查询主机分组
	_, err = db.Table("host_manage").Where("is_delete = 0 AND id = ?", id).Get(&hostManage)
	if err != nil {
		err = resp.DbSelectError.WithError(err)
		return
	}
	//查询主机列表
	err = db.Table("host_manage_list").Where("is_delete = 0 AND host_group_id = ?", id).Find(&hostList)
	if err != nil {
		err = resp.DbSelectError.WithError(err)
		return
	}
	//查询任务列表
	err = db.Table("task_manage").Where("is_delete = 0 AND host_group_id = ?", id).Find(&taskList)
	if err != nil {
		err = resp.DbSelectError.WithError(err)
		return
	}

	for _, v := range hostList {
		if v.HostFileUrl != "" {
			hostManageRes.HostFileUrl = v.HostFileUrl
		}

	}

	hostManageRes.Id = hostManage.Id
	hostManageRes.HostName = hostManage.HostName
	hostManageRes.TaskCnt = len(taskList)
	hostManageRes.IpCnt = len(hostList)
	hostManageRes.CreateUser = hostManage.CreateUser
	hostManageRes.CreateTime = hostManage.CreateTime
	hostManageRes.UpdateUser = hostManage.UpdateUser
	hostManageRes.UpdateTime = hostManage.UpdateTime
	hostManageRes.HostList = hostList
	hostManageRes.TaskList = taskList

	return
}

// ListHostManage 列表
func (h *HostManageSvc) ListHostManage(req request.ListHostManageReq) (total int64, hostManageListRes []response.HostManagesRes, err error) {
	db, err := client.GetDbClient()
	if err != nil {
		err = resp.DbConnectError.WithError(err)
		return
	}

	finder := db.Table("host_manage").Alias("hm").Where("hm.is_delete = 0")
	if req.Search != "" {
		finder.Where("hm.host_name LIKE ?", "%"+req.Search+"%")
	}
	if req.CreateDateFrom != "" {
		finder.Where("hm.create_time >= ?", req.CreateDateFrom)
	}
	if req.CreateDateTo != "" {
		finder.Where("hm.create_time <= ?", req.CreateDateFrom)
	}
	finder.OrderBy("hm.id")
	//查询任务
	total, err = finder.Select("hm.id,hm.host_name,hm.create_user,hm.create_time,(SELECT COUNT(*) FROM "+
		"task_manage tm WHERE tm.is_delete = 0 AND tm.host_group_id = hm.ID) AS task_cnt,(SELECT COUNT(*) FROM "+
		"host_manage_list hml WHERE hml.is_delete = 0 AND hml.conn_status = 0 AND hml.host_group_id = hm.ID) AS "+
		"ip_cnt_err,(SELECT COUNT(*) FROM host_manage_list hml WHERE hml.is_delete = 0 AND hml.host_group_id = hm.ID) AS ip_cnt").
		Limit(req.PageSize, (req.Page-1)*req.PageSize).FindAndCount(&hostManageListRes)
	if err != nil {
		err = resp.DbSelectError.WithError(err)
		return
	}
	return
}

// ListStateHostManage 列表状态检测
func (h *HostManageSvc) ListStateHostManage(req request.StateHostManageReq) (err error) {
	db, err := client.GetDbClient()
	if err != nil {
		err = resp.DbConnectError.WithError(err)
		return
	}

	// 开启事务
	session := db.NewSession()
	defer session.Close()
	session.Begin()

	//查询主机IP列表
	hostManageList := make([]response.HostManageListRes, 0)
	finder := session.Table("host_manage_list").Where("is_delete = 0 AND host_group_id = ?", req.Id)
	err = finder.Find(&hostManageList)
	if err != nil {
		err = resp.DbSelectError.WithError(err)
		return
	}

	//往hosts文件中写入主机组ip
	//f, err := os.OpenFile("/etc/ansible/hosts", os.O_APPEND|os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0777)
	//if err != nil {
	//	err = resp.FileExecError.WithError(err)
	//	return
	//}
	//defer f.Close()
	//for _, v := range hostManageList {
	//	_, err = f.Write([]byte(fmt.Sprintf("%s ansible_ssh_host=%s ansible_ssh_port=%s ansible_ssh_user=\"%s\" ansible_ssh_pass=\"%s\"\n", v.Ip, v.Ip, v.Port, v.UserName, v.Password)))
	//	if err != nil {
	//		return resp.FileExecError.WithError(err)
	//	}
	//}

	for _, v := range hostManageList {
		//状态检测
		ipConn := StatusDetection(v.Ip)

		var state int
		if ipConn {
			//连接正常
			state = 0
		} else {
			//连接异常
			state = 1
		}

		//修改状态
		_, err = session.Table("host_manage_list").Where("is_delete = 0 AND id = ?", v.Id).
			Cols("conn_status").Update(&entity.HostManageList{
			ConnStatus: state,
		})
		if err != nil {
			err = resp.DbUpdateError.WithError(err)
			session.Rollback()
			return
		}
	}

	session.Commit()
	return
}

// SaveStateHostManage 保存时状态检测
func (h *HostManageSvc) SaveStateHostManage(hostManageList []request.HostManageList) (id string, err error) {
	db, err := client.GetDbClient()
	if err != nil {
		err = resp.DbConnectError.WithError(err)
		return
	}
	//处理ip列表
	ipGroup := 1
	HostManageListCaches := make([]entity.HostManageListCache, 0)
	for _, v := range hostManageList {
		port := "22"
		if v.Port != "" {
			port = v.Port
		}
		ipList := strings.Split(v.Ip, ",")

		for _, v1 := range ipList {
			HostManageListCache := entity.HostManageListCache{
				Ip:          v1,
				Port:        port,
				VoucherType: v.VoucherType,
				UserName:    v.UserName,
				Password:    v.Password,
				IpGroup:     ipGroup,
			}
			HostManageListCaches = append(HostManageListCaches, HostManageListCache)
		}
		ipGroup += 1
	}

	//状态检测
	id = uuid.New().String()
	if err != nil {
		err = resp.FAIL.WithError(err)
		return
	}
	for k, _ := range HostManageListCaches {
		//调用状态检测函数
		cc := true

		if cc {
			//正常
			HostManageListCaches[k].ConnStatus = 0
		} else {
			//异常
			HostManageListCaches[k].ConnStatus = 1
		}
		HostManageListCaches[k].Id = id
	}

	//存入数据库
	_, err = db.Table("host_manage_list_cache").Insert(&HostManageListCaches)
	if err != nil {
		err = resp.DbInsertError.WithError(err)
		return
	}
	return
}

// HostIpExceptionList 列表点击状态检测
func (h *HostManageSvc) HostIpExceptionList(req request.HostIpExceptionListReq) (total int64, hostManageListRes []response.HostManageListRes, err error) {
	db, err := client.GetDbClient()
	if err != nil {
		err = resp.DbConnectError.WithError(err)
		return
	}

	finder := db.Table("host_manage_list").Where("conn_status = 1 AND is_delete = 0 AND host_group_id = ?", req.Id)
	//查询
	total, err = finder.Select("id,ip,port,voucher_type,user_name,password").OrderBy("id").
		Limit(req.PageSize, (req.Page-1)*req.PageSize).FindAndCount(&hostManageListRes)
	if err != nil {
		err = resp.DbSelectError.WithError(err)
		return
	}
	return
}

// SaveIpExceptionList 保存时状态检测异常列表
func (h *HostManageSvc) SaveIpExceptionList(req request.HostIpExceptionListReq) (total int64, hostManageListCacheRes response.HostManageListCacheRes, err error) {
	db, err := client.GetDbClient()
	if err != nil {
		err = resp.DbConnectError.WithError(err)
		return
	}

	//异常ip列表-分页
	finder := db.Table("host_manage_list_cache").Where("conn_status = 1 AND id = ?", req.Uuid)
	//查询
	total, err = finder.OrderBy("ip_group").Limit(req.PageSize, (req.Page-1)*req.PageSize).FindAndCount(&hostManageListCacheRes.AbnormalHost)
	if err != nil {
		err = resp.DbSelectError.WithError(err)
		return
	}

	//正常ip列表
	finder1 := db.Table("host_manage_list_cache").Where("conn_status = 0 AND id = ?", req.Uuid)
	//查询
	err = finder1.OrderBy("ip_group").Find(&hostManageListCacheRes.AormalHost)
	if err != nil {
		err = resp.DbSelectError.WithError(err)
		return
	}

	//删除临时数据
	_, err = db.Table("host_manage_list_cache").Where("id = ?", req.Uuid).Delete()
	if err != nil {
		err = resp.DbDeleteError.WithError(err)
		return
	}

	return
}

// StatusDetection 状态检测
func StatusDetection(ip string) (ipConn bool) {

	var cmd *exec.Cmd

	cmd = exec.Command("ansible", fmt.Sprintf("%s", ip), "-m", "ping")

	output, err := cmd.Output()
	if err != nil {
		fmt.Println("执行错误：", err)
		err = resp.CmdExecError.WithError(err)
		return
	}
	fmt.Println("执行成功：")
	fmt.Println(string(output))
	//return string(output), nil

	return
}