package battle

import (
	"context"
	"go_dreamfactory/comm"
	"go_dreamfactory/lego/base"
	"go_dreamfactory/lego/core"
	"go_dreamfactory/lego/sys/log"
	"go_dreamfactory/modules"
	"go_dreamfactory/pb"
	"go_dreamfactory/sys/db"
	"time"
)

/*
模块名:战斗模块
描述:处理游侠战斗相关业务
开发:李伟
*/
func NewModule() core.IModule {
	m := new(Battle)
	return m
}

type Battle struct {
	modules.ModuleBase
	service     base.IRPCXService
	options     *Options
	friend      comm.IFriend      //好友系统
	moonfantasy comm.IMoonFantasy //月之秘境模块
	pvp         comm.IPvp         //实时pvp
	api_comp    *apiComp
	configure   *configureComp
	modelBattle *modelBattleComp
	clientmgr   *battleClientMgrComp //c#战斗客户端端管理
}

//模块名
func (this *Battle) GetType() core.M_Modules {
	return comm.ModuleBattle
}

func (this *Battle) NewOptions() (options core.IModuleOptions) {
	return new(Options)
}

//模块初始化接口 注册用户创建角色事件
func (this *Battle) Init(service core.IService, module core.IModule, options core.IModuleOptions) (err error) {
	err = this.ModuleBase.Init(service, module, options)
	this.service = service.(base.IRPCXService)
	this.options = options.(*Options)
	return
}
func (this *Battle) Start() (err error) {
	if err = this.ModuleBase.Start(); err != nil {
		return
	}
	var module core.IModule
	if module, err = this.service.GetModule(comm.ModuleFriend); err != nil {
		return
	}
	this.friend = module.(comm.IFriend)
	if module, err = this.service.GetModule(comm.ModuleMoonfantasy); err != nil {
		return
	}
	this.moonfantasy = module.(comm.IMoonFantasy)
	if module, err = this.service.GetModule(comm.ModulePvp); err != nil {
		return
	}
	this.pvp = module.(comm.IPvp)
	return
}

//装备组件
func (this *Battle) OnInstallComp() {
	this.ModuleBase.OnInstallComp()
	this.api_comp = this.RegisterComp(new(apiComp)).(*apiComp)
	this.configure = this.RegisterComp(new(configureComp)).(*configureComp)
	this.modelBattle = this.RegisterComp(new(modelBattleComp)).(*modelBattleComp)
	this.clientmgr = this.RegisterComp(new(battleClientMgrComp)).(*battleClientMgrComp)
}

//查询战斗记录
func (this *Battle) QueryBattleRecord(oid string) (errdata *pb.ErrorData, record *pb.DBBattleRecord) {
	var err error
	if record, err = this.modelBattle.queryrecord(oid); err != nil {
		errdata = &pb.ErrorData{
			Code:  pb.ErrorCode_BattleNoFoundRecord,
			Title: pb.ErrorCode_BattleNoFoundRecord.ToString(),
		}
		return
	}
	return
}

//创建pve战斗
func (this *Battle) CreateEveBattle(session comm.IUserSession, req *pb.BattleEVEReq) (errdata *pb.ErrorData, record *pb.DBBattleRecord) {
	var (
		conn *db.DBConn
		err  error
	)
	if !this.IsCross() {
		conn, err = db.Local()
	} else {
		conn, err = db.ServerDBConn(session.GetServiecTag())
	}
	if err != nil {
		errdata = &pb.ErrorData{
			Code:    pb.ErrorCode_DBError,
			Title:   pb.ErrorCode_DBError.ToString(),
			Message: err.Error(),
		}
		this.Errorf("session:%v err:", session, err)
		return
	}

	if record, errdata = this.modelBattle.createeve(session, conn, pb.BattleType_eve, req); errdata != nil {
		return
	}
	return
}

//创建pve战斗
func (this *Battle) CreatePveBattle(session comm.IUserSession, req *pb.BattlePVEReq) (errdata *pb.ErrorData, record *pb.DBBattleRecord) {
	var (
		conn *db.DBConn
		err  error
	)
	if !this.IsCross() {
		conn, err = db.Local()
	} else {
		conn, err = db.ServerDBConn(session.GetServiecTag())
	}
	if err != nil {
		errdata = &pb.ErrorData{
			Code:    pb.ErrorCode_DBError,
			Title:   pb.ErrorCode_DBError.ToString(),
			Message: err.Error(),
		}
		this.Errorf("session:%v err:", session, err)
		return
	}
	if req.Format == nil || req.Format.Format == nil || len(req.Format.Format) != 5 {
		errdata = &pb.ErrorData{
			Code:  pb.ErrorCode_ReqParameterError,
			Title: pb.ErrorCode_ReqParameterError.ToString(),
		}
		return
	}
	if req.Format.Friendformat != nil && len(req.Format.Friendformat) != 5 {
		errdata = &pb.ErrorData{
			Code:  pb.ErrorCode_ReqParameterError,
			Title: pb.ErrorCode_ReqParameterError.ToString(),
		}
	}
	for _, v := range req.Format.Friendformat {
		if v != "" {
			// this.ModuleBuried.SendToRtask(session, comm.Rtype108, 1)
			go this.ModuleBuried.TriggerBuried(session.GetUserId(), comm.GetBuriedParam(comm.Rtype108, 1))
			break
		}
	}

	if record, errdata = this.modelBattle.createpve(session, conn, pb.BattleType_pve, req); errdata != nil {
		return
	}
	if req.Format.Friendformat != nil {
		go this.ModuleBuried.TriggerBuried(session.GetUserId(), comm.GetBuriedParam(comm.Rtype12, 1))
	}
	return
}

//创建pve战斗
func (this *Battle) CreatePvbBattle(session comm.IUserSession, req *pb.BattlePVBReq) (errdata *pb.ErrorData, record *pb.DBBattleRecord) {
	var (
		conn *db.DBConn
		err  error
	)
	if !this.IsCross() {
		conn, err = db.Local()
	} else {
		conn, err = db.ServerDBConn(session.GetServiecTag())
	}
	if err != nil {
		errdata = &pb.ErrorData{
			Code:    pb.ErrorCode_DBError,
			Title:   pb.ErrorCode_DBError.ToString(),
			Message: err.Error(),
		}
		this.Errorf("session:%v err:", session, err)
		return
	}
	if req.Format == nil || len(req.Format) == 0 {
		errdata = &pb.ErrorData{
			Code:  pb.ErrorCode_ReqParameterError,
			Title: pb.ErrorCode_ReqParameterError.ToString(),
		}
		return
	}
	if record, errdata = this.modelBattle.createpvb(session, conn, pb.BattleType_pvb, req); errdata != nil {
		return
	}
	return
}

//创建pve战斗
func (this *Battle) CreatePvpBattle(session comm.IUserSession, req *pb.BattlePVPReq) (errdata *pb.ErrorData, record *pb.DBBattleRecord) {
	var (
		conn *db.DBConn
		err  error
	)
	if !this.IsCross() {
		conn, err = db.Local()
	} else {
		conn, err = db.ServerDBConn(session.GetServiecTag())
	}
	if err != nil {
		errdata = &pb.ErrorData{
			Code:    pb.ErrorCode_DBError,
			Title:   pb.ErrorCode_DBError.ToString(),
			Message: err.Error(),
		}
		this.Errorf("session:%v err:", session, err)
		return
	}
	if record, errdata = this.modelBattle.createpvp(session, conn, pb.BattleType_pvp, req); errdata != nil {
		return
	}
	return
}

//只有跨服环境下才可使用
func (this *Battle) CreateRtPvpBattle(req *pb.BattleRTPVPReq) (errdata *pb.ErrorData, record *pb.DBBattleRecord) {
	var (
		redmodel  *db.DBModel
		bluemodel *db.DBModel
		err       error
	)
	if !this.IsCross() {
		errdata = &pb.ErrorData{
			Code:  pb.ErrorCode_Exception,
			Title: pb.ErrorCode_Exception.ToString(),
		}
		return
	}
	if redmodel, err = this.GetDBModelByUid(req.RedCompId, comm.TableHero); err != nil {
		errdata = &pb.ErrorData{
			Code:    pb.ErrorCode_DBError,
			Title:   pb.ErrorCode_DBError.ToString(),
			Message: err.Error(),
		}
		return
	}
	if bluemodel, err = this.GetDBModelByUid(req.BlueCompId, comm.TableHero); err != nil {
		errdata = &pb.ErrorData{
			Code:    pb.ErrorCode_DBError,
			Title:   pb.ErrorCode_DBError.ToString(),
			Message: err.Error(),
		}
		return
	}
	if record, errdata = this.modelBattle.creatertpvp(redmodel, bluemodel, pb.BattleType_rtpvp, req); errdata != nil {
		return
	}
	return
}

//创建连续战斗
func (this *Battle) CreateLPVEBattle(session comm.IUserSession, req *pb.BattleLPVEReq) (errdata *pb.ErrorData, record *pb.DBBattleRecord) {
	var (
		conn *db.DBConn
		err  error
	)
	if !this.IsCross() {
		conn, err = db.Local()
	} else {
		conn, err = db.ServerDBConn(session.GetServiecTag())
	}
	if err != nil {
		errdata = &pb.ErrorData{
			Code:    pb.ErrorCode_DBError,
			Title:   pb.ErrorCode_DBError.ToString(),
			Message: err.Error(),
		}
		this.Errorf("session:%v err:", session, err)
		return
	}
	if req.Format == nil || req.Format.Format == nil || len(req.Format.Format) != 5 {
		errdata = &pb.ErrorData{
			Code:  pb.ErrorCode_ReqParameterError,
			Title: pb.ErrorCode_ReqParameterError.ToString(),
		}
		return
	}
	if req.Format.Friendformat != nil && len(req.Format.Friendformat) != 5 {
		errdata = &pb.ErrorData{
			Code:  pb.ErrorCode_ReqParameterError,
			Title: pb.ErrorCode_ReqParameterError.ToString(),
		}
	}
	for _, v := range req.Format.Friendformat {
		if v != "" {
			// this.ModuleBuried.SendToRtask(session, comm.Rtype108, 1)
			go this.ModuleBuried.TriggerBuried(session.GetUserId(), comm.GetBuriedParam(comm.Rtype108, 1))
			break
		}
	}

	if record, errdata = this.modelBattle.createlpve(session, conn, pb.BattleType_lpev, req); errdata != nil {
		return
	}
	if req.Format.Friendformat != nil {
		go this.ModuleBuried.TriggerBuried(session.GetUserId(), comm.GetBuriedParam(comm.Rtype12, 1))
	}
	return
}

///创建角色列表 更具Format表格
func (this *Battle) CreateRolesByFormat(fid int32) (captain int32, roles []*pb.BattleRole, errdata *pb.ErrorData) {
	captain, roles, errdata = this.modelBattle.createMasterRoles(2, 0, fid)
	return
}

///创建角色列表 更具英雄列表
func (this *Battle) CreateRolesByHeros(heros []*pb.DBHero) (roles []*pb.BattleRole, errdata *pb.ErrorData) {
	roles = make([]*pb.BattleRole, len(heros))
	for i, v := range heros {
		if v != nil {
			if roles[i], errdata = this.modelBattle.createBattleRole(v, 200+i, i); errdata != nil {
				return
			}
		}
	}
	return
}

///获取战斗详情
func (this *Battle) GetBattleInfo(req *pb.BattleGetInfoReq) (errdata *pb.ErrorData, resp *pb.BattleGetInfoResp) {
	this.Debug("GetBattleInfo", log.Field{Key: "req", Value: req})
	var (
		ctx context.Context
		err error
	)
	ctx, _ = context.WithTimeout(context.Background(), time.Second*5)
	if resp, err = this.clientmgr.GetInfo(ctx, req); err != nil {
		this.Errorln(err)
		errdata = &pb.ErrorData{
			Code:  pb.ErrorCode_RpcFuncExecutionError,
			Title: pb.ErrorCode_RpcFuncExecutionError.ToString(),
		}
	}
	return
}

//创建战斗服务
func (this *Battle) CreateBattleServer(req *pb.BattleInfo) (errdata *pb.ErrorData) {
	this.Debug("CreateBattleServer", log.Field{Key: "req", Value: req})
	var (
		resp *pb.BattleCreateServerResp
		ctx  context.Context
		err  error
	)
	ctx, _ = context.WithTimeout(context.Background(), time.Second*5)
	if resp, err = this.clientmgr.CreateBattle(ctx, &pb.BattleCreateServerReq{Info: req}); err != nil {
		this.Errorln(err)
		errdata = &pb.ErrorData{
			Code:  pb.ErrorCode_RpcFuncExecutionError,
			Title: pb.ErrorCode_RpcFuncExecutionError.ToString(),
		}
	}
	if !resp.Issucc {
		errdata = &pb.ErrorData{
			Code:  pb.ErrorCode_BattleCreateFailed,
			Title: pb.ErrorCode_BattleCreateFailed.ToString(),
		}
	}
	return
}

func (this *Battle) InCmdBattle(req *pb.BattleInCmdReq) (errdata *pb.ErrorData) {
	var (
		resp *pb.BattleInCmdResp
		ctx  context.Context
		err  error
	)
	ctx, _ = context.WithTimeout(context.Background(), time.Second*5)
	if resp, err = this.clientmgr.InCmdBattle(ctx, req); err != nil {
		this.Errorln(err)
		errdata = &pb.ErrorData{
			Code:  pb.ErrorCode_RpcFuncExecutionError,
			Title: pb.ErrorCode_RpcFuncExecutionError.ToString(),
		}
	}
	if !resp.Issucc {
		errdata = &pb.ErrorData{
			Code:  pb.ErrorCode_BattleInCmdFailed,
			Title: pb.ErrorCode_BattleInCmdFailed.ToString(),
		}
	}
	return
}

//pvp认输
func (this *Battle) ConcedeBattle(req *pb.BattleConcedeReq) (errdata *pb.ErrorData) {
	var (
		resp *pb.BattleConcedeResp
		err  error
	)
	if resp, err = this.clientmgr.ConcedeBattle(context.Background(), req); err != nil {
		this.Errorln(err)
		errdata = &pb.ErrorData{
			Code:  pb.ErrorCode_RpcFuncExecutionError,
			Title: pb.ErrorCode_RpcFuncExecutionError.ToString(),
		}
	}
	if !resp.Issucc {
		errdata = &pb.ErrorData{
			Code:  pb.ErrorCode_BattleInCmdFailed,
			Title: pb.ErrorCode_BattleInCmdFailed.ToString(),
		}
	}
	return
}

//校验战报是否成功
func (this *Battle) CheckBattleReport(session comm.IUserSession, report *pb.BattleReport) (errdata *pb.ErrorData, iswin bool) {
	var (
		reply *pb.BattleCheckResults
		ctx   context.Context
		err   error
	)
	if report == nil {
		iswin = false
		return
	}

	if this.options.OpenCheck {
		stime := time.Now()
		ctx, _ = context.WithTimeout(context.Background(), time.Second*5)
		if reply, err = this.clientmgr.CheckBattle(ctx, report); err != nil || !reply.Ischeck {
			errdata = &pb.ErrorData{
				Code:  pb.ErrorCode_BattleValidationFailed,
				Title: pb.ErrorCode_BattleValidationFailed.ToString(),
			}
			this.Error("[Battle Check]",
				log.Field{Key: "t", Value: time.Since(stime).Milliseconds()},
				log.Field{Key: "reply", Value: reply.String()},
				log.Field{Key: "err", Value: err.Error()},
			)
			return
		}
		this.Debug("[Battle Check]",
			log.Field{Key: "t", Value: time.Since(stime).Milliseconds()},
			log.Field{Key: "reply", Value: reply.String()},
		)
	}
	this.moonfantasy.Trigger(session, report)
	for _, v := range report.Completetask {
		// this.ModuleBuried.SendToRtask(session, comm.Rtype157, int32(report.Info.Ptype), v)
		go this.ModuleBuried.TriggerBuried(session.GetUserId(), comm.GetBuriedParam(comm.Rtype157, int32(report.Info.Ptype), v))
	}
	return nil, true
}