package cust

import (
	"bytes"
	"context"
	"encoding/csv"
	"math"
	"sort"
	"strconv"
	"time"

	"github.com/gogf/gf/errors/gerror"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/os/gtime"
	"github.com/gogf/gf/util/gconv"

	"dashoo.cn/micro/app/dao/cust"
	platdao "dashoo.cn/micro/app/dao/plat"
	model "dashoo.cn/micro/app/model/cust"
	"dashoo.cn/micro/app/service"
)

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

var derivetable = []string{"客户编码", "客户名称", "助记名", "所在地区", "客户行业", "客户行业", "客户状态", "最后跟进时间", "创建人", "创建时间"}

type CustomerService struct {
	*service.ContextService
	Dao         *cust.CustCustomerDao
	BelongDao   *cust.CustCustomerBelongDao
	DynamicsDao *cust.CustCustomerDynamicsDao
	ContactDao  *cust.CustCustomerContactDao
	FollowDao   *platdao.PlatFollowupDao
}

var isPublic, noPublic = "10", "20" // 公海,非公海
var isTransfer int8 = 1             //转移
var isAllocation int8 = 2           //分配 Allocation
var OperaTion, AllocaTion = "20", "10"

type OpnType struct {
	OperaTion string
}

func NewCustomerService(ctx context.Context) (svc *CustomerService, err error) {
	svc = new(CustomerService)
	if svc.ContextService, err = svc.Init(ctx); err != nil {
		return nil, err
	}
	svc.Dao = cust.NewCustCustomerDao(svc.Tenant)
	svc.BelongDao = cust.NewCustCustomerBelongDao(svc.Tenant)
	svc.DynamicsDao = cust.NewCustCustomerDynamicsDao(svc.Tenant)
	svc.ContactDao = cust.NewCustCustomerContactDao(svc.Tenant)
	svc.FollowDao = platdao.NewPlatFollowupDao(svc.Tenant)
	return svc, nil
}

//导出数据
func (c *CustomerService) Derive(req *model.CustCustomerSearchReq) (bytesBuffer *bytes.Buffer, err error) {
	//file, err := os.Create("cust_list.csv")
	//g.Log().Info("xxxx", "cust_list")
	//if err != nil {
	//	fmt.Println("open file is failed, err: ", err)
	//}
	req.TargetType = "11"
	_, data, _ := c.GetList(req)
	// 延迟关闭
	//buffer := &bytes.Buffer{}
	bytesBuffer = &bytes.Buffer{}
	bytesBuffer.WriteString("xEFxBBxBF")
	//defer file.Close()
	//// 写入UTF-8 BOM，防止中文乱码
	//	buffer.WriteString("\xEF\xBB\xBF")
	w := csv.NewWriter(bytesBuffer)
	// 写入数据
	w.Write(derivetable)
	w.Flush()
	// Map写入
	m := make(map[int][]string)
	for k, v := range data {
		m[k] = []string{v.CustCode, v.CustName, v.AbbrName, v.CustLocation, v.CustIndustry, v.CustLevel, v.CustStatus,
			gconv.String(v.FollowUpDate), v.CreatedName, gconv.String(v.CreatedTime)}
	}
	// 按照key排序
	var keys []int
	for k := range m {
		keys = append(keys, k)
	}
	sort.Ints(keys)
	for _, key := range keys {
		w.Write(m[key])
		// 刷新缓冲
	}
	w.Flush()

	return
}

//创建客户
func (c *CustomerService) Create(req *model.Customer) (insertId int64, err error) {
	cusTomer := new(model.CustCustomer)
	g.Log().Info(err)
	Model := c.Dao.M
	record, err := Model.Where(g.Map{"cust_name": req.CustName}).One()
	g.Log().Info("recordE", record.IsEmpty())
	if err != nil || !record.IsEmpty() {
		err = gerror.New("该客户信息已存在,不可重复添加")
		return
	}
	//OpnPeopleId int         ` json:"opnPeopleId"` // 操作人ID
	//OpnPeople   string      ` json:"opnPeople"`   // 操作人
	//OpnDate     *gtime.Time ` json:"opnDate"`     // 操作日期
	//OpnType     string      ` json:"opnType"`     // 操作类型
	//OpnContent  string      ` json:"opnContent"`  // 操作内容

	//c.OperationLog()
	if err = gconv.Struct(req, cusTomer); err != nil {
		return
	}
	g.Log().Info("部门ID", c.CxtUser.DeptId)
	service.SetCreatedInfo(cusTomer, c.GetCxtUserId(), c.GetCxtUserName())
	cusTomer.CustCode = strconv.Itoa(int(gtime.Timestamp()))
	cusTomer.IsPublic = isPublic
	cusTomer.CustStatus = "10"
	//if c.CxtUser.DeptId == 2 {
	//	cusTomer.IsPublic = noPublic            //   非公海用户
	//	cusTomer.DeptId = c.GetCxtUserDeptId()  //   部门id
	//	cusTomer.DeptId = c.GetCxtUserDeptId()  //   部门名称
	//	cusTomer.SalesId = c.GetCxtUserId()     //   销售id
	//	cusTomer.SalesName = c.GetCxtUserName() //   销售名称
	//}
	res, err := Model.Insert(cusTomer)
	if err != nil {
		g.Log().Error(err)
		err = gerror.New("创建失败")
		return
	}
	//

	insertId, _ = res.LastInsertId()

	//销售人员创建条件成立 同步belong 表
	//custBelong := new(model.AddCustomerBelong)
	//custBelong.CustId = int(insertId)
	//custBelong.SaleName = "xxx"
	//custBelong.OpnPeople = "xxxx"
	//custBelong.OpnDatetime = gtime.Now()
	//err = c.CreateBelong()
	return
}

//销售人员创建 直接认领客户
func (c *CustomerService) CreateBelong(req *model.AddCustomerBelong) (err error) {
	cusTomerBelong := new(model.CustCustomerBelong)
	if err = gconv.Struct(req, cusTomerBelong); err != nil {
		g.Log().Info("error", err)
		return
	}
	service.SetCreatedInfo(cusTomerBelong, c.GetCxtUserId(), c.GetCxtUserName())

	cusTomerBelong.OpnType = isPublic
	cusTomerBelong.OpnDatetime = gtime.Now()
	service.SetCreatedInfo(cusTomerBelong, c.GetCxtUserId(), c.GetCxtUserName())
	_, err = c.BelongDao.Insert(cusTomerBelong)
	if err != nil {
		g.Log().Error(err)
		err = gerror.New("创建失败")
		return
	}
	return nil

}

//客户列表列表
func (c *CustomerService) GetList(req *model.CustCustomerSearchReq) (total int, customerList []*model.CustList, err error) {
	g.Log().Info("serverS", req)
	Model := c.Dao.M
	Model = Model.Where(c.Dao.Columns.DeletedTime + " is null")
	if req.TargetType == "" {
		if !req.IsPublic {
			g.Log().Info("ISPUblic", "xxxxxx")
			Model = Model.Where(c.Dao.Columns.SalesId, c.CxtUser.Id).Where(c.Dao.Columns.IsPublic, noPublic)
		} else {
			g.Log().Info("serverS", req)
			Model = Model.Where(c.Dao.Columns.IsPublic, isPublic)
		}
	}
	//客户名称
	if req.CustName != "" {
		Model = Model.Where(c.Dao.Columns.CustName+" like ?", "%"+req.CustName+"%")
	}
	//客户编码
	if req.CustCode != "" {
		Model = Model.Where(c.Dao.Columns.CustCode+" like ?", "%"+req.CustCode+"%")
	}
	//客户行业
	if req.CustIndustry != "" {
		Model = Model.Where(c.Dao.Columns.CustIndustry+" like ?", "%"+req.CustIndustry+"%")
	}
	//客户级别
	if req.CustLevel != "" {
		Model = Model.Where(c.Dao.Columns.CustLevel, req.CustLevel)
	}
	total, err = Model.Fields().Count()
	if err != nil {
		g.Log().Error(err)
		err = gerror.New("获取总行数失败")
		return
	}
	if req.PageNum == 0 {
		req.PageNum = 1
	}
	err = Model.Page(req.PageNum, req.PageSize).Order("id desc").Scan(&customerList)
	return
}

//删除客户
func (c *CustomerService) DeleteById(id int) error {

	Model := c.Dao.M
	ContactModel := c.ContactDao //联系人
	regionDetail := new(model.CustCustomer)
	err := Model.Where(c.Dao.Columns.Id, id).Scan(&regionDetail)
	//g.Log().Info("DeleteByIds", one)
	if err != nil {
		g.Log().Error(err)
		err = gerror.New("没有要删除的数据")
		return err
	}
	deleteTime := gtime.Now()
	//删除客户表
	_, err = Model.Data(g.Map{
		"deleted_time": deleteTime,
	}).Where(c.Dao.Columns.Id, id).Update()
	// 删除客户联系人表
	_, err = ContactModel.Data(g.Map{
		"deleted_time": deleteTime,
	}).Where(c.ContactDao.Columns.CustId, id).Update()

	if err != nil {
		g.Log().Error(err)
		err = gerror.New("删除数据失败")
		return err
	}
	return nil
}

//修改客户
func (c *CustomerService) UpdateById(req *model.UpdateCustomer) (err error) {
	db := c.Dao.M
	record, err := db.FindOne(c.Dao.Columns.Id, req.Id)
	if err != nil || record.IsEmpty() {
		err = gerror.New("该数据不存在")
		return err
	}
	CustomertData := new(model.Customer)
	if err = gconv.Struct(req, CustomertData); err != nil {
		return
	}
	service.SetUpdatedInfo(CustomertData, c.GetCxtUserId(), c.GetCxtUserName())
	_, err = db.FieldsEx(c.Dao.Columns.CreatedTime, c.Dao.Columns.CreatedBy, c.Dao.Columns.CreatedName, c.Dao.Columns.Id, c.Dao.Columns.CustCode, c.Dao.Columns.SalesName, c.Dao.Columns.SalesId).
		WherePri(c.Dao.Columns.Id, req.Id).Update(CustomertData)

	if err != nil {
		g.Log().Error(err)
		err = gerror.New("修改用户信息失败")
		return
	}
	return
}

//移入公海
func (c *CustomerService) MoveToPubic(ids []int64) error {
	Model := c.Dao.M
	//Cust := new(model.CustCustomer)
	list, err := Model.Fields(c.Dao.Columns.CreatedTime).Where(c.Dao.Columns.Id+" in (?) ", ids).All()
	if err != nil || list.Len() <= 0 {
		g.Log().Error(err)
		err = gerror.New("没有要移除的数据")
		return err
	}
	_, err = Model.Data(g.Map{
		"is_public":    isPublic,
		"sales_id":     0,
		"sales_name":   "",
		"dept_id":      0,
		"dept_name":    "",
		"create_time":  gtime.Now(),
		"updated_by":   c.GetCxtUserId(),
		"updated_name": c.GetCxtUserName(),
		"updated_time": gtime.Now(),
	}).Where(c.ContactDao.Columns.Id+" in (?)", ids).Update()

	if err != nil {
		g.Log().Error(err)
		err = gerror.New("移入公海失败")
		return err
	}
	return nil
}

//分配客户
func (c *CustomerService) DistriCustomer(req *model.DistriCustomer) error {
	/**
	   待写逻辑(销售总监或销售助理将公海客户分配给指定销售工程师)
	   if c.user.id != 销售总监 || c.user.id!=销售助理 {

	      err = gerror.New("该账号无权限操作!")
			return

			}
	*/
	custModel := c.Dao.M
	rep, err := custModel.Where(cust.CustCustomer.Columns.Id+" in (?)  ", req.Ids).Where(cust.CustCustomer.Columns.IsPublic, isPublic).All()
	if err != nil || rep.IsEmpty() {
		err = gerror.New("该数据不存在")
		return err
	}
	err = c.updateCustomer(req.Ids, req.SalesId, req.SalesName)
	if err != nil {
		err = gerror.New("可配客户失败")
		return err

	}
	var maps = make(map[string]string)
	maps["remark"] = req.Remark
	maps["opn_type"] = AllocaTion
	maps["sale_name"] = req.SalesName
	err = c.belongInsters(rep.List(), maps)
	if err != nil {
		err = gerror.New("转移客户失败")
		return err
	}
	return nil
}

//客户详情
func (c *CustomerService) GetEntityById(ids []int64) (entityInfo []*model.CustList, err error) {
	Model := c.Dao.M //
	//FollowModel := c.FollowDao.M

	err = Model.Where(cust.CustCustomer.Columns.Id+" in (?)", ids).Scan(&entityInfo)
	if err != nil {
		g.Log().Error(err)
		return nil, gerror.New("获取用户数据失败")
	}
	return
}

//客户摘要
func (c *CustomerService) CustAbstract(id int64) (followInfo *model.Follow, err error) {
	custModel := c.Dao.M //
	Model := c.FollowDao.M

	count, err := Model.Where(c.FollowDao.Columns.CustId, id).Count()
	g.Log().Info("count", count)
	if err != nil {
		g.Log().Error(err)
		return nil, gerror.New("获取用户数据失败")
	}

	followInfo = new(model.Follow)
	followInfo.FollowCount = count
	//
	find, err := custModel.Fields(c.Dao.Columns.FollowUpDate).Where(c.Dao.Columns.Id, id).FindOne()

	if err != nil {
		g.Log().Error(err)
		return nil, gerror.New("获取用户数据失败")
	}
	if find.IsEmpty() {
		followInfo.NotFollowDay = 0
	}
	findOne := find.Map()
	//followDate, err := Model.Fields("max(next_time) as next_time").Where(c.FollowDao.Columns.CustId, id).Where(c.FollowDao.Columns.FollowDate, findOne["follow_up_date"]).FindOne()
	//if followDate.IsEmpty() {
	//	followInfo.NotFollowDay = 0
	//}
	//followNextTime := followDate.Map()
	//next_time := gconv.String(followNextTime["next_time"])
	upDate := gconv.String(findOne["follow_up_date"])
	follow_up, err1 := time.Parse(TIME_LAYOUT, upDate)
	now := gtime.Now()
	follow_next, err2 := time.Parse(TIME_LAYOUT, gconv.String(now))
	if err1 != nil || err2 != nil {
		followInfo.NotFollowDay = 0
	}
	poor := follow_next.Sub(follow_up)
	g.Log().Info("xxxxfdsaf", poor)
	hours := float64(poor.Hours() / 24)
	if hours < 0 {
		followInfo.NotFollowDay = 0
	} else {
		followInfo.NotFollowDay = int(math.Floor(hours))
	}

	//g.Log().Info("findOne_time", findOne["follow_up_date"])
	//g.Log().Info("next_time", next_time)
	//g.Log().Info("ceil", math.Ceil(hours))
	return
}

//转移客户
func (c *CustomerService) UpdateBytransfer(req *model.CustSalesReq) (entityInfo []*model.CustCustomer, err error) {
	custModel := c.Dao.M
	rep, err := custModel.Fields("sales_id,sales_name,id").Where(cust.CustCustomer.Columns.Id+" in (?)", req.Ids).All()
	if err != nil || rep.IsEmpty() {
		err = gerror.New("该数据不存在")
		return
	}
	err = c.updateCustomer(req.Ids, req.SalesIds, req.SalesName)
	if err != nil {
		err = gerror.New("转移客户失败")
		return
	}

	var maps = make(map[string]string)
	maps["remark"] = req.Remark
	maps["opn_type"] = OperaTion
	maps["sale_name"] = req.SalesName
	err = c.belongInsters(rep.List(), maps)
	if err != nil {
		err = gerror.New("转移客户失败")
		return
	}
	return
}

//变更客户所属关系
func (c *CustomerService) updateCustomer(ids []int64, salesId int64, salesName string) error {
	custModel := c.Dao.M

	_, err := custModel.Data(g.Map{
		"sales_id":     salesId,
		"is_public":    noPublic,
		"sales_name":   salesName,
		"updated_by":   c.GetCxtUserId(),
		"updated_name": c.GetCxtUserName(),
		"updated_time": gtime.Now(),
	}).Where(cust.CustCustomer.Columns.Id+" in (?)", ids).Update()

	if err != nil {
		g.Log().Error(err)
		err = gerror.New("变更失败")
		return err
	}
	return nil
}

//客户操作日志
func (c *CustomerService) OperationLog(ctx context.Context, ids []int64, req *model.AddCustomerDynameicsReq) (err error) {
	g.Log("fdasfsa", gconv.String(ctx))
	cusDynameics := new(model.CustCustomerDynamics)
	if err = gconv.Struct(req, cusDynameics); err != nil {
		g.Log().Info("error", err)
		return
	}
	Model := c.DynamicsDao.M
	g.Log().Info("IDS", ids)

	maps := []map[string]interface{}{}
	for _, v := range ids {
		contact := map[string]interface{}{}
		contact["cust_id"] = v
		contact["opn_people_id"] = c.GetCxtUserId()
		contact["opn_people"] = c.GetCxtUserName()
		contact["opn_date"] = req.OpnDate
		contact["opn_type"] = req.OpnType
		contact["remark"] = ""
		contact["created_by"] = c.GetCxtUserId()
		contact["created_name"] = c.GetCxtUserName()
		contact["created_by"] = c.GetCxtUserId()
		contact["created_time"] = gtime.Now()
		contact["opn_content"] = req.OpnContent
		maps = append(maps, contact)
	}
	_, err = Model.Insert(maps)
	if err != nil {
		g.Log().Error(err)
		err = gerror.New("创建失败")
		return
	}
	return
}

//客户动态
func (c *CustomerService) DynamicsList(req *model.CustomerDynameicsReq) (total int, result []interface{}, err error) {
	Model := c.DynamicsDao.M
	total, err = Model.Fields().Count()
	if err != nil {
		g.Log().Error(err)
		err = gerror.New("获取总行数失败")
		return
	}
	if req.PageNum == 0 {
		req.PageNum = 1
	}
	dynamics := []*model.CustomerDynameicsRep{}
	err = Model.Page(req.PageNum, req.PageSize).Where("cust_id = ", req.CustId).Order("id desc").Scan(&dynamics)
	dynamicsList := make(map[string][]*model.CustomerDynameicsRep)

	for _, v := range dynamics {
		gt1 := gtime.New(v.OpnDate)
		opnDate := gt1.Format("Y-m-d")
		dynamicsList[opnDate] = append(dynamicsList[opnDate], &model.CustomerDynameicsRep{
			OpnPeople:  v.OpnPeople,
			OpnDate:    v.OpnDate,
			OpnType:    v.OpnType,
			OpnContent: v.OpnContent,
		})

	}
	g.Log().Info("DynamicsList----", dynamicsList)
	result = append(result, dynamicsList)
	return
}

//合并客户
func (c *CustomerService) Mergecustomer(req *model.MergecustomerRep) (err error) {
	Model := c.Dao.M
	ContactModel := c.ContactDao.M
	BelongDao := c.BelongDao.M
	//当前目标客户是否存在
	FindOne, err := Model.Where(c.Dao.Columns.DeletedTime+" is  null").Where(c.Dao.Columns.Id, req.Id).FindOne()
	if err != nil || FindOne.IsEmpty() {
		err = gerror.New("该数据不存在")
		return
	}
	//所选客户联系人信息
	List, err := ContactModel.Where(c.ContactDao.Columns.CustId+" in (?)", req.ChooseId).All()
	g.Log().Info("list", List.List())
	CustomertData := new(model.Customer)
	if err = gconv.Struct(req, CustomertData); err != nil {
		return
	}
	service.SetUpdatedInfo(CustomertData, c.GetCxtUserId(), c.GetCxtUserName())
	_, err = Model.FieldsEx(c.Dao.Columns.CreatedTime, c.Dao.Columns.CreatedBy,
		c.Dao.Columns.CreatedName, c.Dao.Columns.Id,
		c.Dao.Columns.CustCode,
		c.Dao.Columns.SalesName,
		c.Dao.Columns.SalesId).WherePri(c.Dao.Columns.Id, req.Id).Update(CustomertData)
	if err != nil {
		err = gerror.New("合并失败")
		return
	}
	Model.Data(g.Map{"deleted_time": gtime.Now()}).Where(c.ContactDao.Columns.Id+" in (?)", req.ChooseId).Update()
	if err != nil || List.Len() > 0 {
		err = c.contactInster(req.Id, req.ChooseId, List.List())
		if err != nil {
			err = gerror.New("合并失败")
			return
		}
	}
	////所选客户销售联系人信息
	BelongList, err := BelongDao.Where(c.BelongDao.Columns.CustId+" in (?)", req.ChooseId).All()
	if err != nil || BelongList.Len() > 0 {
		err = c.belongInster(req.Id, req.ChooseId, req.Customer.SalesName)
		if err != nil {
			err = gerror.New("合并失败")
			return
		}
	}
	return
}

//联系人
func (c *CustomerService) contactInster(id int, Ids []int64, list []map[string]interface{}) (err error) {
	ContactModel := c.ContactDao.M
	ContactModel.Data(g.Map{"deleted_time": gtime.Now()}).Where(c.ContactDao.Columns.CustId+" in (?)", Ids).Update()
	maps := []map[string]interface{}{}
	for _, v := range list {
		contact := map[string]interface{}{}
		contact["cust_id"] = id
		contact["cuct_name"] = v["cuct_name"]
		contact["cuct_gender"] = v["cuct_gender"]
		contact["postion"] = v["postion"]
		contact["telephone"] = v["telephone"]
		contact["wechat"] = v["wechat"]
		contact["email"] = v["email"]
		contact["policy"] = v["policy"]
		contact["remark"] = v["remark"]
		contact["created_by"] = v["created_by"]
		contact["created_name"] = v["created_name"]
		contact["created_time"] = v["created_time"]
		maps = append(maps, contact)
	}
	_, err = ContactModel.Insert(maps)
	if err != nil {
		err = gerror.New("操作失败")
		g.Log().Info("contactInster", err)
		return

	}

	return
}

//销售
func (c *CustomerService) belongInster(Id int, BelongIds []int64, SaleName string) (err error) {
	BelongDao := c.BelongDao.M
	BelongDao.Data(g.Map{"deleted_time": gtime.Now()}).Where(c.BelongDao.Columns.CustId+" in (?)", BelongIds).Update()
	BelongData := new(model.CustCustomerBelong)
	BelongData.CustId = Id
	service.SetCreatedInfo(BelongData, c.GetCxtUserId(), c.GetCxtUserName())
	BelongData.SaleName = SaleName
	BelongData.OpnType = AllocaTion
	BelongData.OrigSaleName = ""
	BelongData.OpnPeople = "admin"
	BelongData.OpnDatetime = gtime.Now()
	_, err = BelongDao.Insert(BelongData)
	if err != nil {
		g.Log().Info("BeloongInster", err)
		err = gerror.New("操作失败")
		return
	}
	return
}

//批量插入客户归属记录表
func (c *CustomerService) belongInsters(rep []map[string]interface{}, parameter map[string]string) (err error) {
	belongModel := c.BelongDao.M
	maps := []map[string]interface{}{}
	date_time := gtime.Now()
	for _, v := range rep {
		orig_sale_name := v["sales_name"]
		belong := map[string]interface{}{}
		belong["cust_id"] = v["id"].(int)
		belong["sale_name"] = parameter["sale_name"]
		belong["orig_sale_name"] = orig_sale_name
		belong["opn_type"] = parameter["opn_type"]
		belong["opn_people"] = 1
		belong["opn_datetime"] = date_time
		belong["created_by"] = 1
		belong["remark"] = parameter["remark"]
		belong["created_name"] = "admin"
		belong["created_time"] = date_time
		belong["opn_datetime"] = date_time
		maps = append(maps, belong)
	}
	_, err = belongModel.Insert(maps)
	if err != nil {
		err = gerror.New("插入失败")
		return err
	}

	return
}