package store

import (
	"context"
	"fmt"
	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/errors/gerror"
	"server/internal/consts"
	"server/internal/dao"
	"server/internal/model"
	"server/internal/model/do"
	"server/internal/service"
	"server/utility/ecode"
	"server/utility/snowid"
)

type sStore struct {
}

func New() service.IStore {
	return &sStore{}
}
func init() {
	service.RegisterStore(New())
}
func (s *sStore) List(ctx context.Context, in *model.StoreListIn) (out *model.StoreListOut, err error) {
	// 1. 初始化返回数据
	list := make([]model.Store, 0)
	var total int
	if err = dao.Stores.Ctx(ctx).Page(in.Page, in.Size).Where(do.Stores{MerchantId: in.MerchantId}).ScanAndCount(&list, &total, false); err != nil {
		return nil, ecode.Fail.Sub("门店列表获取失败")
	}
	return &model.StoreListOut{
		List:  list,
		Total: total,
	}, nil
}

func (s *sStore) Create(ctx context.Context, in *model.StoreCreateIn) (out *model.CreateOut, err error) {
	out = &model.CreateOut{}
	// 1. 检查门店名称是否重复
	exist, err := dao.Stores.Ctx(ctx).Where(do.Stores{Name: in.Name}).Exist()
	if err != nil {
		return nil, ecode.Fail.Sub("新增门店查重出现异常")
	}
	if exist {
		return nil, ecode.Params.Sub("门店名称已存在")
	}

	// 2. 使用事务处理数据插入
	if err = dao.Stores.Transaction(ctx, func(ctx context.Context, tx gdb.TX) (err error) {
		// 2.1 根据商户 id 获取所属的商户
		value, err := dao.MerchantAdmins.Ctx(ctx).WherePri(in.OperatorId).Fields(dao.MerchantAdmins.Columns().MerchantId).Value()
		if err != nil {
			return ecode.Fail.Sub("获取商户ID出现异常")
		}
		// 2,2 生成门店的相关信息
		code, err := snowid.GetSnowClient().GenerateStoreCode()
		if err != nil {
			return ecode.Fail.Sub("生成门店ID出现异常")
		}
		// 2.3 插入门店数据
		id, err := tx.Model(dao.Stores.Table()).Data(do.Stores{
			MerchantId:   value.Int(),
			StoreCode:    code,
			Name:         in.Name,
			Address:      in.Address,
			ContactName:  in.ContactName,
			ContactPhone: in.ContactPhone,
		}).InsertAndGetId()
		if err != nil {
			return ecode.Fail.Sub("新增门店出现异常")
		}

		// TODO 生成门店主管理账号,密码通知方式

		// 2.5 插入门店管理员数据
		_, err = tx.Model(dao.StoreAdmins.Table()).Data(do.StoreAdmins{
			StoreId: id,
		}).Insert()
		if err != nil {
			return ecode.Fail.Sub("新增门店管理员出现异常")
		}
		out.Id = id
		return nil
	}); err != nil {
		return nil, err
	}
	return
}

func (s *sStore) Update(ctx context.Context, in *model.StoreUpdateIn) (out *model.UpdateOut, err error) {
	exist, err := dao.Stores.Ctx(ctx).WherePri(in.Id).Exist()
	if err != nil {
		return nil, ecode.Fail.Sub("查询门店出现异常")
	}
	if !exist {
		return nil, ecode.Params.Sub("门店不存在")
	}

	if in.OperatorId == 0 || (in.OperatorRole != consts.MerchantRoleCode && in.OperatorRole != consts.StoreRoleCode) {
		return nil, ecode.InvalidOperation.Sub("无权限操作")
	}

	if in.Name != "" {
		exist, err = dao.Stores.Ctx(ctx).Where(dao.Stores.Columns().Name, in.Name).WhereNot(dao.Stores.Columns().Id, in.Id).Exist()
		if err != nil {
			return nil, ecode.Fail.Sub("检查门店名称出现异常")
		}
		if exist {
			return nil, ecode.Params.Sub("门店名称已存在")
		}
	}

	_, err = dao.Stores.Ctx(ctx).WherePri(in.Id).Data(do.Stores{
		Name:         in.Name,
		Address:      in.Address,
		ContactName:  in.ContactName,
		ContactPhone: in.ContactPhone, // TODO：暂定可以直接修改，后续可能需要验证手机号
		Status:       in.Status,
	}).Update()
	if err != nil {
		return nil, ecode.Fail.Sub("更新门店出现异常")
	}
	return &model.UpdateOut{Success: true}, nil
}

func (s *sStore) Delete(ctx context.Context, in *model.StoreDeleteIn) (out *model.DeleteOut, err error) {
	exist, err := dao.Stores.Ctx(ctx).WherePri(in.Id).Exist()
	if err != nil {
		return nil, ecode.Fail.Sub("查询门店出现异常")
	}
	if !exist {
		return nil, ecode.Params.Sub("门店不存在")
	}

	if in.OperatorId == 0 || (in.OperatorRole != consts.MerchantRoleCode) {
		return nil, ecode.InvalidOperation.Sub("无权限操作")
	}
	// TODO: 是否需要检查门店下存在未发放奖励等

	return &model.DeleteOut{Success: true}, nil
}

func (s *sStore) Info(ctx context.Context, in *model.StoreInfoIn) (out *model.StoreInfoOut, err error) {
	exist, err := dao.Stores.Ctx(ctx).Where(do.Stores{Id: in.Id}).Exist()
	if err != nil {
		return nil, ecode.Fail.Sub("查询门店出现异常")
	}
	if !exist {
		return nil, ecode.Params.Sub("门店不存在")
	}

	// TODO 获取门店信息等相关信息
	return
}

func (s *sStore) GetDesktopSetting(ctx context.Context, in *model.StoreGetDesktopSettingIn) (*model.StoreGetDesktopSettingOut, error) {
	// 检查门店桌面设置是否存在
	exist, err := dao.StoreDesktopSettings.Ctx(ctx).Where(do.StoreDesktopSettings{StoreId: in.StoreId}).Count()
	if err != nil {
		return nil, gerror.Wrap(ecode.Fail, "查询门店桌面设置出现异常")
	}
	if exist == 0 {
		return &model.StoreGetDesktopSettingOut{}, nil
	}

	// 查询桌面设置
	out := &model.StoreGetDesktopSettingOut{}
	err = dao.StoreDesktopSettings.Ctx(ctx).Where(do.StoreDesktopSettings{StoreId: in.StoreId}).Scan(out)
	if err != nil {
		return nil, gerror.Wrap(ecode.Fail, "查询门店桌面设置出现异常")
	}

	return out, nil
}

func (s *sStore) GetIPList(ctx context.Context, in *model.IPListIn) (*model.IPListout, error) {

	m := dao.StoreIps.Ctx(ctx)
	if in.StoreId > 0 {
		m = m.Where(do.StoreIps{
			StoreId: in.StoreId,
		})
	}

	var list []model.StoreIps
	var total int

	err := m.Page(in.Page, in.Size).ScanAndCount(&list, &total, false)
	if err != nil {
		return nil, ecode.Fail.Sub("IP列表获取失败")
	}

	return &model.IPListout{
		List:  list,
		Total: int64(total),
	}, nil
}

func (s *sStore) CreateIP(ctx context.Context, in *model.IPCreateIn) (*model.IPCreateOut, error) {

	exist, err := dao.StoreIps.Ctx(ctx).Where(do.StoreIps{StoreId: in.StoreId, IpAddress: in.Ip}).Exist()

	if err != nil {
		return nil, ecode.Fail.Sub("门店IP创建失败")
	}

	if exist {
		return nil, ecode.Params.Sub("门店IP已存在")
	}

	_, err = dao.StoreIps.Ctx(ctx).Insert(do.StoreIps{
		IpAddress: in.Ip,
		Remark:    in.Remark,
		StoreId:   in.StoreId,
	})
	if err != nil {
		return nil, ecode.Fail.Sub("门店IP创建失败")
	}
	return &model.IPCreateOut{
		Success: true,
	}, nil
}

func (s *sStore) UpdateIP(ctx context.Context, in *model.IPUpdateIn) (*model.IPUpdateOut, error) {

	//exist, err := dao.StoreIps.Ctx(ctx).Where(do.StoreIps{StoreId: in.StoreId, IpAddress: in.Ip}).Exist()
	//
	//if err != nil {
	//	return nil, ecode.Fail.Sub("门店IP更新失败")
	//}
	//
	//if exist {
	//	return nil, ecode.Params.Sub("门店IP已存在")
	//}

	_, err := dao.StoreIps.Ctx(ctx).Where(do.StoreIps{Id: in.Id}).Data(do.StoreIps{IpAddress: in.Ip, Remark: in.Remark}).Update()
	if err != nil {
		return nil, ecode.Fail.Sub("门店IP更新失败")
	}
	return &model.IPUpdateOut{
		Success: true,
	}, nil
}

func (s *sStore) DeleteIP(ctx context.Context, in *model.IPDeleteIn) (*model.IPDeleteOut, error) {

	exist, err := dao.StoreIps.Ctx(ctx).Where(do.StoreIps{Id: in.Id}).Exist()

	if err != nil {
		return nil, ecode.Fail.Sub("门店IP查询失败")
	}

	if !exist {
		return nil, ecode.Params.Sub("门店不已存在")
	}

	_, err = dao.StoreIps.Ctx(ctx).Where(do.StoreIps{Id: in.Id}).Delete()
	if err != nil {
		return nil, ecode.Fail.Sub("删除门店IP失败")
	}
	return &model.IPDeleteOut{
		Success: true,
	}, nil
}

func (s *sStore) Detail(ctx context.Context, in *model.StoreDetailIn) (out *model.StoreDetailOut, err error) {
	one, err := dao.Stores.Ctx(ctx).Where(do.Stores{Id: in.StoreId}).One()
	if err != nil {
		return nil, ecode.Fail.Sub("查询门店出现异常")
	}
	if one.IsEmpty() {
		return nil, ecode.Params.Sub("门店不存在")
	}
	return &model.StoreDetailOut{
		Id:            one[dao.Stores.Columns().Id].Int64(),
		NetbarAccount: one[dao.Stores.Columns().NetbarAccount].String(),
	}, nil
}

func (s *sStore) GetStoreMemberList(ctx context.Context, in *model.StoreMemberLevelsListIn) (out *model.StoreMemberLevelsListOut, err error) {

	if in.RoleName != consts.StoreRoleCode && in.RoleName != consts.MerchantRoleCode {
		return nil, ecode.Fail.Sub("无门店权限")
	}

	m := dao.StoreMemberLevels.Ctx(ctx)
	if in.StoreId > 0 {
		m.Where(do.StoreMemberLevels{StoreId: in.StoreId})
	}

	var data []model.StoreMemberLevels
	var total int
	err = m.Page(in.Page, in.Size).ScanAndCount(&data, &total, false)
	if err != nil {
		return nil, ecode.Fail.Sub("门店会员等级列表获取失败")
	}
	return &model.StoreMemberLevelsListOut{
		List:  data,
		Total: total,
	}, nil
}
func (s *sStore) GetStoreAreaList(ctx context.Context, in *model.StoreAreaListIn) (out *model.StoreAreaListOut, err error) {

	// 根据角色权限获取门店ID
	switch in.OperatorRole {
	case consts.MerchantRoleCode:
		exist, err := dao.MerchantAdmins.Ctx(ctx).Where(do.MerchantAdmins{
			MerchantId: in.OperatorId,
		}).LeftJoin(dao.Stores.Table(), fmt.Sprintf("%s.%s = %s.%s", dao.Stores.Table(), dao.Stores.Columns().MerchantId, dao.MerchantAdmins.Table(), dao.MerchantAdmins.Columns().MerchantId)).Where("stores.id = ?", in.StoreId).Exist()
		if err != nil {
			return nil, ecode.Fail.Sub("检查商户权限失败")
		}
		if !exist {
			return nil, ecode.Params.Sub("无门店权限")
		}
	case consts.StoreRoleCode:
		// 检查门店管理员是否有该门店权限
		value, err := dao.StoreAdmins.Ctx(ctx).WherePri(in.OperatorId).Fields(dao.StoreAdmins.Columns().StoreId).Value()
		if err != nil {
			return nil, ecode.Fail.Sub("检查门店权限失败")
		}
		if value.IsEmpty() || value.Int64() != in.StoreId {
			return nil, ecode.Params.Sub("无门店权限")
		}
	default:
		return nil, ecode.Params.Sub("无操作权限")
	}
	out = &model.StoreAreaListOut{}
	if err = dao.StoreAreas.Ctx(ctx).Where(do.StoreAreas{StoreId: in.StoreId}).ScanAndCount(&out.List, &out.Total, false); err != nil {
		return nil, ecode.Fail.Sub("门店区域列表获取失败")
	}
	return
}

func (s *sStore) GetNetfeeSetting(ctx context.Context, in *model.GetNetfeeSettingIn) (out *model.StoreNetfeeAreaLevel, err error) {
	out = &model.StoreNetfeeAreaLevel{}
	one, err := dao.StoreNetfeeAreaLevel.Ctx(ctx).Where(do.StoreNetfeeAreaLevel{StoreId: in.StoreId, RewardId: in.RewardId, AreaId: in.AreaId, MemberLevelId: in.MemberLevelId}).One()
	if err != nil {
		return nil, ecode.Fail.Sub("门店区域价格获取失败")
	}
	if one.IsEmpty() {
		return
	}
	if err = one.Struct(out); err != nil {
		return nil, ecode.Fail.Sub("门店区域价格获取失败")
	}
	return
}
func (s *sStore) SaveNetfeeSetting(ctx context.Context, in *model.SaveNetfeeSettingIn) (out *model.SaveNetfeeSettingOut, err error) {
	exist, err := dao.StoreNetfeeAreaLevel.Ctx(ctx).Where(do.StoreNetfeeAreaLevel{StoreId: in.StoreId, RewardId: in.RewardId, AreaId: in.AreaId, MemberLevelId: in.MemberLevelId}).Exist()
	if err != nil {
		return nil, ecode.Fail.Sub("门店区域价格保存失败")
	}
	if exist {
		_, err = dao.StoreNetfeeAreaLevel.Ctx(ctx).Where(do.StoreNetfeeAreaLevel{StoreId: in.StoreId, RewardId: in.RewardId, AreaId: in.AreaId, MemberLevelId: in.MemberLevelId}).
			Update(do.StoreNetfeeAreaLevel{PriceData: in.PriceData})
		if err != nil {
			return nil, ecode.Fail.Sub("门店区域价格保存失败")
		}
	} else {
		_, err = dao.StoreNetfeeAreaLevel.Ctx(ctx).Insert(do.StoreNetfeeAreaLevel{
			AreaId:        in.AreaId,
			MemberLevelId: in.MemberLevelId,
			PriceData:     in.PriceData,
			RewardId:      in.RewardId,
			StoreId:       in.StoreId,
		})
		if err != nil {
			return nil, ecode.Fail.Sub("门店区域价格保存失败")
		}
	}
	return &model.SaveNetfeeSettingOut{
		Success: true,
	}, nil
}

// GetStoreInfoByNetbarAccount 根据网关账号获取门店信息
func (s *sStore) GetStoreInfoByNetbarAccount(ctx context.Context, in *model.StoreByNetbarAccountIn) (out *model.StoreByNetbarAccountOut, err error) {

	var data model.Store
	if err = dao.Stores.Ctx(ctx).Where(do.Stores{NetbarAccount: in.NetbarAccount}).Fields(dao.Stores.Columns().Id, dao.Stores.Columns().Name).Scan(&data); err != nil {
		return nil, ecode.Fail.Sub("查询门店信息失败")
	}
	return &model.StoreByNetbarAccountOut{
		Store: data,
	}, nil
}