package cases

import (
	"errors"
	"spaceofcheng/services/models"
	"spaceofcheng/services/models/cases"
	"spaceofcheng/services/models/customer"
	"spaceofcheng/services/models/model"
	"spaceofcheng/services/models/system"
	"spaceofcheng/services/service"
	"spaceofcheng/services/utils"
)

// CaseServ 系统处理
type CaseServ struct {
	ctx         *utils.Context
	dao         *cases.CaseDAO
	userdao     *system.UserDAO
	customerdao *customer.CustomerDAO
}

// NewCaseServ 初始化
func NewCaseServ(ctx *utils.Context) *CaseServ {
	return &CaseServ{
		ctx:         ctx,
		dao:         cases.NewCaseDAO(ctx),
		userdao:     system.NewUserDAO(ctx),
		customerdao: customer.NewCustomerDAO(ctx),
	}
}

const (
	CONFTYPE_GOODS = "goods"
)

// GetCases 获取案场列表
func (s *CaseServ) GetCases(caseids, casename string, page, pageSize int) (map[string]interface{}, error) {
	if pageSize == 0 {
		pageSize = service.PAGENUM
	}
	if page == 0 {
		page = 1
	}
	cases, err := s.dao.GetCaseList(caseids, casename, page, pageSize)
	if err != nil {
		utils.LogError("获取案场信息失败: " + err.Error())
		return nil, errors.New("获取案场信息失败")
	}
	total, err := s.dao.GetCaseCount(caseids, casename)
	if err != nil {
		utils.LogError("获取案场信息失败: " + err.Error())
		return nil, errors.New("获取案场信息失败")
	}

	return map[string]interface{}{
		"list":     cases,
		"pagesize": pageSize,
		"pagenum":  total,
		"page":     page,
	}, err
}

// GetCaseByID 根据案场id获取案场
func (s *CaseServ) GetCaseByID(caseid string) (*model.SysCase, error) {
	caseinfo, err := s.dao.GetCaseByID(caseid)
	if err != nil {
		utils.LogError("获取案场信息失败: " + err.Error())
		return nil, errors.New("获取案场信息失败")
	}
	return caseinfo, nil
}

// SaveCase 保存案场
func (s *CaseServ) SaveCase(caseinfo model.SysCase) (*model.SysCase, error) {
	var newInfo *model.SysCase
	var err error
	if caseinfo.CaseName == "" {
		return nil, errors.New("请填写案场名称！")
	}
	if caseinfo.CaseAddress == "" {
		return nil, errors.New("请填写案场地址！")
	}
	if caseinfo.CaseIcon == "" {
		return nil, errors.New("请上传案场图片！")
	}
	if caseinfo.Coordinate == "" {
		return nil, errors.New("案场在地图上的位置不明确，请在地图上抓取地址获取经纬度！")
	}

	if caseinfo.CaseId == "" {
		newInfo, err = s.dao.AddCase(caseinfo)
		if err != nil {
			utils.LogError("保存案场信息失败: " + err.Error())
			return nil, errors.New("保存案场信息失败")
		}
		// 新增之后保存用户对应案场
		var userCase = model.SysUserCase{
			CaseId:    newInfo.CaseId,
			UserId:    newInfo.CreateUser,
			CaseName:  newInfo.CaseName,
			IsBelong:  0,
			IsCreated: 1,
		}
		err = s.userdao.SaveUserCase(userCase)
		if err != nil {
			utils.LogError("保存案场信息失败: " + err.Error())
			return nil, errors.New("保存案场信息失败")
		}
		// 新增管理员对应案场
		if newInfo.CreateUser != "1" {
			var userCase = model.SysUserCase{
				CaseId:    newInfo.CaseId,
				UserId:    models.ADMIN_ID,
				CaseName:  newInfo.CaseName,
				IsBelong:  0,
				IsCreated: 0,
			}
			err = s.userdao.SaveUserCase(userCase)
			if err != nil {
				utils.LogError("保存案场信息失败: " + err.Error())
				return nil, errors.New("保存案场信息失败")
			}
		}
		// 新增案场配置信息
		var conf = model.SysCaseConf{
			CaseId:   newInfo.CaseId,
			ConfType: CONFTYPE_GOODS,
		}
		_, err = s.dao.SaveCaseConf(conf)
	} else {
		err = s.dao.UpdateCase(caseinfo)
		newInfo = &caseinfo
		if err != nil {
			utils.LogError("保存案场信息失败: " + err.Error())
			return nil, errors.New("保存案场信息失败")
		}
		err = s.dao.UpdateUserCaseName(caseinfo)
	}
	if err != nil {
		utils.LogError("保存案场信息失败: " + err.Error())
		return nil, errors.New("保存案场信息失败")
	}
	return newInfo, nil
}

// DelCase 删除案场
func (s *CaseServ) DelCase(caseid string) error {
	err := s.dao.DelCase(caseid)
	if err != nil {
		utils.LogError("删除案场信息失败: " + err.Error())
		return errors.New("删除案场信息失败")
	}
	return nil
}

// GetAllCasesAndSales 获取所有案场
func (s *CaseServ) GetAllCasesAndSales(org string) (map[string]interface{}, error) {
	cs, err := s.dao.GetCaseByOrg(org)
	if err != nil {
		utils.LogError("获取案场列表失败: " + err.Error())
		return nil, errors.New("获取案场列表失败")
	}

	csIDs := []string{}
	for _, c := range cs {
		csIDs = append(csIDs, c.CaseId)
	}

	users, err := s.dao.GetCaseUserByType(csIDs, models.USERTYPE_SALES)
	if err != nil {
		utils.LogError("获取案场销售失败: " + err.Error())
		return nil, errors.New("获取案场销售失败")
	}

	manager, err := s.dao.GetCaseUserByType(csIDs, models.USERTYPE_MANAGER)

	return map[string]interface{}{
		"cases":   cs,
		"sales":   users,
		"manager": manager,
	}, nil
}

// GetCaseConf 获取案场配置信息
func (s *CaseServ) GetCaseConf(caseid, conftype string) (*model.SysCaseConf, error) {
	conf, err := s.dao.GetConfByCase(caseid, conftype)
	if err != nil {
		utils.LogError("获取配置信息失败: " + err.Error())
		return nil, errors.New("获取配置信息失败")
	}
	return conf, nil
}

// UpdateCaseConf 修改案场配置信息
func (s *CaseServ) UpdateCaseConf(caseid, conftype string, status int) error {
	var conf = model.SysCaseConf{
		CaseId:   caseid,
		ConfType: conftype,
		Status:   status,
	}
	err := s.dao.UpdateCaseConf(conf)
	return err
}