package component

import (
	"joylink.club/ecs"
	"joylink.club/rtsssimulation/component/component_proto"
)

// 道岔标签
var TurnoutTag = ecs.NewTag()

// // 道岔的实际位置
// type TurnoutPosition struct {
// 	Dw bool // 是否定位(实际位置)
// 	Fw bool // 是否反位(实际位置)

// 	Db bool // 定位表示(表示位置)
// 	Fb bool // 反位表示(表示位置)
// }

// 实际道岔的实际位置组件类型
var TurnoutPositionType = ecs.NewComponentType[component_proto.TurnoutPosition]()

var (
	// 失表故障
	TurnoutFaultSbType = ecs.NewComponentType[component_proto.TurnoutFaultSB]()
	// 定位失表故障
	TurnoutFaultDwsbType = ecs.NewComponentType[component_proto.TurnoutFaultDwsb]()
	// 反位失表故障
	TurnoutFaultFwsbType = ecs.NewComponentType[component_proto.TurnoutFaultFwsb]()
	// 挤岔故障类型
	TurnoutFaultJcType = ecs.NewComponentType[component_proto.TurnoutFaultJc]()
)

// 根据道岔故障枚举获取道岔故障组件类型
func GetTurnoutFaultType(fault component_proto.Turnout_Fault) ecs.IComponentType {
	switch fault {
	case component_proto.Turnout_SB:
		return TurnoutFaultSbType
	case component_proto.Turnout_DWSB:
		return TurnoutFaultDwsbType
	case component_proto.Turnout_FWSB:
		return TurnoutFaultFwsbType
	case component_proto.Turnout_JC:
		return TurnoutFaultJcType
	}
	return nil
}

// ZDJ9单机电路元器件
type Zdj9OneElectronic struct {
	TDC_YCJ *ecs.Entry // 运行操作继电器
	TDC_DCJ *ecs.Entry // 定操继电器
	TDC_FCJ *ecs.Entry // 反操继电器

	TDFJ_BB    *ecs.Entry // 道岔表示变压器
	TDFJ_1DQJ  *ecs.Entry // 一启动继电器
	TDFJ_BHJ   *ecs.Entry // 保护继电器
	TDFJ_2DQJ  *ecs.Entry // 二启动继电器
	TDFJ_1DQJF *ecs.Entry // 一启动复示继电器
	TDFJ_DBQ   *ecs.Entry // 断相保护器
	TDFJ_DBJ   *ecs.Entry // 定位表示继电器
	TDFJ_FBJ   *ecs.Entry // 反位表示继电器
	TDFJ_R1    *ecs.Entry // 电阻
}

// ZDJ9单机电路元器件组件类型
var Zdj9OneElectronicType = ecs.NewComponentType[Zdj9OneElectronic]()

// ZDJ9双机电路元器件
type Zdj9TwoElectronic struct {
	TDC_DCJ  *ecs.Entry // 定操继电器
	TDC_FCJ  *ecs.Entry // 反操继电器
	TDC_YCJ  *ecs.Entry // 允许操作继电器
	TDC_ZDBJ *ecs.Entry // 总定表继电器
	TDC_ZFBJ *ecs.Entry // 总反表继电器

	// 一机
	TDFJ1_1DQJ  *ecs.Entry // 一启动继电器
	TDFJ1_BHJ   *ecs.Entry // 保护继电器
	TDFJ1_2DQJ  *ecs.Entry // 二启动继电器
	TDFJ1_1DQJF *ecs.Entry // 一启动复示继电器
	TDFJ1_DBQ   *ecs.Entry // 断相保护器
	TDFJ1_DBJ   *ecs.Entry // 定位表示继电器
	TDFJ1_FBJ   *ecs.Entry // 反位表示继电器
	TDFJ1_QDJ   *ecs.Entry // 切断继电器
	TDFJ1_ZBHJ  *ecs.Entry // 总保护继电器

	TDFJ1_QDJ_Remain int // 切断继电器保持电路保持剩余时间

	// 二机
	TDFJ2_1DQJ  *ecs.Entry // 一启动继电器
	TDFJ2_BHJ   *ecs.Entry // 保护继电器
	TDFJ2_2DQJ  *ecs.Entry // 二启动继电器
	TDFJ2_1DQJF *ecs.Entry // 一启动复示继电器
	TDFJ2_DBQ   *ecs.Entry // 断相保护器
	TDFJ2_DBJ   *ecs.Entry // 定位表示继电器
	TDFJ2_FBJ   *ecs.Entry // 反位表示继电器
}

// 检查空引用，返回空引用字段名称
func (te *Zdj9TwoElectronic) CheckNilReference() []string {
	var nils []string = make([]string, 0)
	if te.TDC_DCJ == nil {
		nils = append(nils, "TDC_DCJ")
	}
	if te.TDC_FCJ == nil {
		nils = append(nils, "TDC_FCJ")
	}
	if te.TDC_YCJ == nil {
		nils = append(nils, "TDC_YCJ")
	}
	if te.TDC_ZDBJ == nil {
		nils = append(nils, "TDC_ZDBJ")
	}
	if te.TDC_ZFBJ == nil {
		nils = append(nils, "TDC_ZFBJ")
	}
	// 一机
	if te.TDFJ1_1DQJ == nil {
		nils = append(nils, "TDFJ1_1DQJ")
	}
	if te.TDFJ1_BHJ == nil {
		nils = append(nils, "TDFJ1_BHJ")
	}
	if te.TDFJ1_2DQJ == nil {
		nils = append(nils, "TDFJ1_2DQJ")
	}
	if te.TDFJ1_1DQJF == nil {
		nils = append(nils, "TDFJ1_1DQJF")
	}
	if te.TDFJ1_DBQ == nil {
		nils = append(nils, "TDFJ1_DBQ")
	}
	if te.TDFJ1_DBJ == nil {
		nils = append(nils, "TDFJ1_DBJ")
	}
	if te.TDFJ1_FBJ == nil {
		nils = append(nils, "TDFJ1_FBJ")
	}
	if te.TDFJ1_QDJ == nil {
		nils = append(nils, "TDFJ1_QDJ")
	}
	if te.TDFJ1_ZBHJ == nil {
		nils = append(nils, "TDFJ1_ZBHJ")
	}

	// 二机
	if te.TDFJ2_1DQJ == nil {
		nils = append(nils, "TDFJ2_1DQJ")
	}
	if te.TDFJ2_BHJ == nil {
		nils = append(nils, "TDFJ2_BHJ")
	}
	if te.TDFJ2_2DQJ == nil {
		nils = append(nils, "TDFJ2_2DQJ")
	}
	if te.TDFJ2_1DQJF == nil {
		nils = append(nils, "TDFJ2_1DQJF")
	}
	if te.TDFJ2_DBQ == nil {
		nils = append(nils, "TDFJ2_DBQ")
	}
	if te.TDFJ2_DBJ == nil {
		nils = append(nils, "TDFJ2_DBJ")
	}
	if te.TDFJ2_FBJ == nil {
		nils = append(nils, "TDFJ2_FBJ")
	}
	return nils
}

// 是否有空引用
func (te *Zdj9TwoElectronic) HasNilReference() bool {
	nils := te.CheckNilReference()
	return len(nils) > 0
}

// ZDJ9双机驱动状态组件
type Zdj9TwoDrive struct {
	// 定操继电器驱动
	DCJ bool
	// 反操继电器驱动
	FCJ bool
	// 允操继电器驱动
	YCJ bool
}

// ZDJ9双机采集状态组件
type Zdj9TwoCollect struct {
	// 总定表继电器吸起采集
	TDC_ZDBJ_XQ bool
	// 总反表继电器吸起采集
	TDC_ZFBJ_XQ bool
	// 允操继电器吸起采集
	TDC_YCJ_XQ bool
	// 总定表继电器和总反表继电器都落下采集
	TDC_ZDBJ_ZFBJ_LX bool
	// 1机定表继电器吸起采集
	TDFJ1_DBJ_XQ bool
	// 1机反表继电器吸起采集
	TDFJ1_FBJ_XQ bool
	// 2机定表继电器吸起采集
	TDFJ2_DBJ_XQ bool
	// 2机反表继电器吸起采集
	TDFJ2_FBJ_XQ bool
}

var (
	// ZDJ9双机电路元器件组件类型
	Zdj9TwoElectronicType = ecs.NewComponentType[Zdj9TwoElectronic]()
	// ZDJ9双机驱动状态组件类型
	Zdj9TwoDriveType = ecs.NewComponentType[Zdj9TwoDrive]()
	// ZDJ9双机采集状态组件类型
	Zdj9TwoCollectType = ecs.NewComponentType[Zdj9TwoCollect]()
)

// 转辙机状态
type ZzjState struct {
	// 自动开闭器接点位置，默认定位接通1/3排，反位接通2/4排
	// 由定位转反位（1DQJ和1DQJF励磁吸起，2DQJ在反位——即落下），三相电路导通，电机开始反转，转辙机将第3排接点接通第4排，到位锁闭后，转辙机的自动开闭器拉簧将第1排接点拉到第2排，接点到2排后，三相电路断路
	// 由反位转定位（1DQJ和1DQJF励磁吸起，2DQJ在定位——即吸起），三相电路导通，电机开始正转，转辙机将第2排接点接通第1排，到位锁闭后，转辙机的自动开闭器拉簧将第4排接点拉到第3排，接点到3排后，三相电路断路
	JD12 bool // 接点在1/2排的位置，false-接点在1排，true-接点在2排
	JD34 bool // 接点在3/4排的位置，false-接点在3排，true-接点在4排

	Td bool // 是否通电
	Dw bool // 是否转动到定位
}

// 转辙机状态
var ZzjStateType = ecs.NewComponentType[ZzjState]()

// 道岔的转辙机引用
type TurnoutZzj struct {
	ZzjList []*ecs.Entry
}

func (tz *TurnoutZzj) GetZzj1() *ecs.Entry {
	len := len(tz.ZzjList)
	if len > 0 {
		return tz.ZzjList[0]
	}
	panic("道岔没有转辙机一")
}

func (tz *TurnoutZzj) GetZzj2() *ecs.Entry {
	len := len(tz.ZzjList)
	if len > 1 {
		return tz.ZzjList[1]
	}
	panic("道岔没有转辙机二")
}

var TurnoutZzjType = ecs.NewComponentType[TurnoutZzj]()

func GetTurnoutZzj1(entry *ecs.Entry) *ecs.Entry {
	if entry.HasComponent(TurnoutZzjType) {
		zzjs := TurnoutZzjType.Get(entry)
		return zzjs.GetZzj1()
	}
	panic("道岔没有转辙机引用组件")
}

func GetTurnoutZzj1State(entry *ecs.Entry) *ZzjState {
	if entry.HasComponent(TurnoutZzjType) {
		zzjs := TurnoutZzjType.Get(entry)
		zzj := zzjs.GetZzj1()
		return ZzjStateType.Get(zzj)
	}
	panic("道岔没有转辙机引用组件")
}

func GetTurnoutZzj2(entry *ecs.Entry) *ecs.Entry {
	if entry.HasComponent(TurnoutZzjType) {
		zzjs := TurnoutZzjType.Get(entry)
		return zzjs.GetZzj2()
	}
	panic("道岔没有转辙机引用组件")
}

func GetTurnoutZzj2State(entry *ecs.Entry) *ZzjState {
	if entry.HasComponent(TurnoutZzjType) {
		zzjs := TurnoutZzjType.Get(entry)
		zzj := zzjs.GetZzj2()
		return ZzjStateType.Get(zzj)
	}
	panic("道岔没有转辙机引用组件")
}