package partner

import (
	"bytes"
	"context"
	"database/sql"
	"fmt"
	"strings"

	dao "dashoo.cn/micro/app/dao/partner"
	model "dashoo.cn/micro/app/model/partner"

	"dashoo.cn/opms_libary/micro_srv"
	"dashoo.cn/opms_libary/myerrors"
	"dashoo.cn/opms_libary/request"
	"github.com/gogf/gf/database/gdb"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/os/gtime"
	"github.com/gogf/gf/util/gvalid"
	"github.com/xuri/excelize/v2"
)

type PartnerCompanyContactService struct {
	Dao       *dao.PartnerCompanyContactDao
	ParterDao *dao.PartnerCompanyDao

	Tenant    string
	userInfo  request.UserInfo
	DataScope g.Map `json:"dataScope"`
}

func NewPartnerCompanyContactService(ctx context.Context) (*PartnerCompanyContactService, error) {
	tenant, err := micro_srv.GetTenant(ctx)
	if err != nil {
		err = myerrors.TipsError(fmt.Sprintf("获取租户码异常：%s", err.Error()))
		return nil, err
	}
	// 获取用户信息
	userInfo, err := micro_srv.GetUserInfo(ctx)
	if err != nil {
		return nil, fmt.Errorf("获取用户信息异常：%s", err.Error())
	}
	return &PartnerCompanyContactService{
		Dao:       dao.NewPartnerCompanyContactDao(tenant),
		ParterDao: dao.NewPartnerCompanyDao(tenant),
		Tenant:    tenant,
		userInfo:  userInfo,
		DataScope: userInfo.DataScope,
	}, nil
}

func (s PartnerCompanyContactService) Get(ctx context.Context, id int) (*model.PartnerCompanyContact, error) {
	ent, err := s.Dao.Where("Id = ?", id).One()
	if err != nil {
		return nil, err
	}
	if ent == nil {
		return nil, myerrors.TipsError("合作伙伴不存在")
	}
	return ent, nil
}

func (s PartnerCompanyContactService) List(ctx context.Context, req *model.PartnerCompanyContactListReq) (int, []*model.PartnerCompanyContact, error) {
	dao := &s.Dao.PartnerCompanyContactDao
	if req.PartnerId != 0 {
		dao = dao.Where("partner_id = ?", req.PartnerId)
	}
	if req.Name != "" {
		likestr := fmt.Sprintf("%%%s%%", req.Name)
		dao = dao.Where("name like ?", likestr)
	}
	if req.Post != "" {
		dao = dao.Where("post = ?", req.Post)
	}

	total, err := dao.Count()
	if err != nil {
		return 0, nil, err
	}
	if req.PageNum != 0 {
		dao = dao.Page(req.GetPage())
	}
	orderby := "created_time desc"
	if req.OrderBy != "" {
		orderby = req.OrderBy
	}
	dao = dao.Order(orderby)

	ents := []*model.PartnerCompanyContact{}
	err = dao.Structs(&ents)
	if err != nil && err != sql.ErrNoRows {
		return 0, nil, err
	}
	return total, ents, err
}

func (s PartnerCompanyContactService) Add(ctx context.Context, req *model.PartnerCompanyContactAddReq) (int, error) {
	validErr := gvalid.CheckStruct(ctx, req, nil)
	if validErr != nil {
		return 0, myerrors.TipsError(validErr.Current().Error())
	}
	ent, err := s.ParterDao.Where("id = ?", req.PartnerId).One()
	if err != nil {
		return 0, err
	}
	if ent == nil {
		return 0, myerrors.TipsError(fmt.Sprintf("合作伙伴不存在: %d", req.PartnerId))
	}

	var id int
	txerr := s.Dao.DB.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
		var err error
		cid, err := tx.InsertAndGetId("partner_company_contact", model.PartnerCompanyContact{
			PartnerId:   req.PartnerId,
			Name:        req.Name,
			Post:        req.Post,
			ContactWay:  req.ContactWay,
			Territory:   req.Territory,
			Remark:      req.Remark,
			CreatedBy:   int(s.userInfo.Id),
			CreatedName: s.userInfo.NickName,
			CreatedTime: gtime.Now(),
			UpdatedBy:   int(s.userInfo.Id),
			UpdatedName: s.userInfo.NickName,
			UpdatedTime: gtime.Now(),
		})
		if err != nil {
			return err
		}
		id = int(cid)
		return nil
	})
	return id, txerr
}

func (s PartnerCompanyContactService) Update(ctx context.Context, req *model.PartnerCompanyContactUpdateReq) error {
	validErr := gvalid.CheckStruct(ctx, req, nil)
	if validErr != nil {
		return myerrors.TipsError(validErr.Current().Error())
	}

	ent, err := s.Dao.Where("id = ?", req.Id).One()
	if err != nil {
		return err
	}
	if ent == nil {
		return myerrors.TipsError(fmt.Sprintf("合作伙伴联系人不存在: %d", req.Id))
	}

	toupdate := map[string]interface{}{}
	if req.Name != "" {
		toupdate["name"] = req.Name
	}
	if req.Post != nil {
		toupdate["post"] = *req.Post
	}
	if req.ContactWay != nil {
		toupdate["contact_way"] = *req.ContactWay
	}
	if req.Territory != nil {
		toupdate["territory"] = *req.Territory
	}
	if req.Remark != nil {
		toupdate["remark"] = *req.Remark
	}
	if len(toupdate) != 0 {
		toupdate["updated_by"] = int(s.userInfo.Id)
		toupdate["updated_name"] = s.userInfo.NickName
		toupdate["updated_time"] = gtime.Now()
		txerr := s.Dao.DB.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
			_, err = tx.Update("partner_company_contact", toupdate, "id = ?", req.Id)
			if err != nil {
				return err
			}
			return nil
		})
		if txerr != nil {
			return txerr
		}
	}
	return nil
}

func (s PartnerCompanyContactService) ExcelUpload(ctx context.Context, req *model.PartnerCompanyContactExcelUploadReq) error {
	validErr := gvalid.CheckStruct(ctx, req, nil)
	if validErr != nil {
		return myerrors.TipsError(validErr.Current().Error())
	}
	ent, err := s.ParterDao.Where("id = ?", req.PartnerId).One()
	if err != nil {
		return err
	}
	if ent == nil {
		return myerrors.TipsError(fmt.Sprintf("合作伙伴不存在: %d", req.PartnerId))
	}

	b, err := DownFile(req.ExcelUrl)
	if err != nil {
		return myerrors.TipsError(fmt.Sprintf("下载 excel 异常 %s", err.Error()))
	}
	contact, err := s.ParseExcel(req.PartnerId, b)
	// err = ioutil.WriteFile("text.xlsx", b, 777)
	// fmt.Println(err)

	if err != nil {
		return myerrors.TipsError(fmt.Sprintf("解析 excel 异常 %s", err.Error()))
	}
	_, err = s.Dao.Insert(contact)
	return err
}

func (s PartnerCompanyContactService) ParseExcel(partnerId int, b []byte) ([]model.PartnerCompanyContact, error) {
	f, err := excelize.OpenReader(bytes.NewBuffer(b))
	if err != nil {
		return nil, err
	}
	sheet := "Sheet1"
	rows, err := f.GetRows(sheet)
	if err != nil {
		return nil, err
	}

	contact := []model.PartnerCompanyContact{}
	for rown, row := range rows[1:] {
		rown += 1
		if len(row) < 4 {
			return nil, fmt.Errorf("excel 格式错误：列数小于4列")
		}

		name := strings.TrimSpace(row[0])
		post := strings.TrimSpace(row[1])
		contactWay := strings.TrimSpace(row[2])
		territory := strings.TrimSpace(row[3])
		var remark string
		if len(row) > 4 {
			remark = strings.TrimSpace(row[4])
		}
		contact = append(contact, model.PartnerCompanyContact{
			PartnerId:   partnerId,
			Name:        name,
			Post:        post,
			ContactWay:  contactWay,
			Territory:   territory,
			Remark:      remark,
			CreatedBy:   int(s.userInfo.Id),
			CreatedName: s.userInfo.NickName,
			CreatedTime: gtime.Now(),
			UpdatedBy:   int(s.userInfo.Id),
			UpdatedName: s.userInfo.NickName,
			UpdatedTime: gtime.Now(),
		})
	}
	return contact, nil
}

func (s PartnerCompanyContactService) Delete(ctx context.Context, id []int) error {
	if len(id) == 0 {
		return nil
	}
	_, err := s.Dao.Where("Id  IN (?)", id).Delete()
	return err
}

var contactExcelHeader = []ExcelHeader{
	{Name: "联系人", Width: 30},
	{Name: "岗位", Width: 30},
	{Name: "联系方式", Width: 30},
	{Name: "负责区域", Width: 30},
	{Name: "备注", Width: 40},
}

func ExcelTemplate() (*excelize.File, error) {
	tempData := [][]string{
		{"张三", "销售", "18000000000", "崂山", ""},
	}
	return NewExcel(contactExcelHeader, tempData)
}