package server

import (
	"chat-agent-system/internal/app/intentflow"
	"chat-agent-system/internal/app/stageflow"
	"chat-agent-system/internal/auth"
	"chat-agent-system/internal/authz"
	"chat-agent-system/internal/bizdev"
	"chat-agent-system/internal/coordinator"
	"chat-agent-system/internal/ctxmgr"
	"chat-agent-system/internal/docgov"
	"chat-agent-system/internal/docrevision"
	"chat-agent-system/internal/freedoc"
	"chat-agent-system/internal/intent"
	"chat-agent-system/internal/kb"
	"chat-agent-system/internal/maintenance"
	"chat-agent-system/internal/notification"
	"chat-agent-system/internal/projectinstance"
	"chat-agent-system/internal/projectworkflow"
	"chat-agent-system/internal/storage"
	"chat-agent-system/internal/sysadmin"
	"chat-agent-system/internal/taskrun"
	"chat-agent-system/internal/workflowdef"
	"chat-agent-system/internal/workspace"
)

// 本文件集中承接 Server 对 app.Runtime 领域服务的访问（module-batches-ag 镜像字段收口）。
// Server 不再镜像 Runtime 字段；全部经访问器取用，nil 安全。
// testOverrides 仅供测试注入替换件；set 字段后（含显式置 nil 经 *X 指针形）覆盖访问器结果，
// 生产路径恒为空。显式置 nil 用 ptr 形（authorizerPtr 等）以区分「未设置」与「设为 nil」。

type serverTestOverrides struct {
	svc         *bizdev.Service
	pwSvc       *projectworkflow.Service
	engine      *coordinator.CoordinatorEngine
	authSvc     *auth.Service
	taskRuns    *taskrun.Manager
	authorizer  *authz.Authorizer
	authzSvc    *authz.Service
	wfDefSvc    *workflowdef.Service
	instSvc     *projectinstance.Service
	notifySvc   *notification.Service
	resolver    *workspace.Resolver
	wsCap       *workspace.Capability
	cmds        *taskrun.Commands
	stageflow   *stageflow.UseCase
	gov         *docgov.GovernanceEngine
	rev         *docrevision.Service
	ctxMgr      *ctxmgr.ContextManager
	cas         *storage.CAS
	freeDoc     *freedoc.Service
	kb          *kb.Client
	sysadmin    *sysadmin.Service
	maintenance *maintenance.Service

	// 显式置 nil 的位标记（区分「未设置」与「设为 nil」，fail-closed 测试用）。
	authorizerNil bool
	instSvcNil    bool
}

func (s *Server) overrides() *serverTestOverrides {
	if s == nil {
		return nil
	}
	return s.testOverrides
}

func (s *Server) svc() *bizdev.Service {
	if o := s.overrides(); o != nil && o.svc != nil {
		return o.svc
	}
	if s == nil || s.rt == nil {
		return nil
	}
	return s.rt.Biz
}

func (s *Server) pwSvc() *projectworkflow.Service {
	if o := s.overrides(); o != nil && o.pwSvc != nil {
		return o.pwSvc
	}
	if s == nil || s.rt == nil {
		return nil
	}
	return s.rt.PW
}

func (s *Server) rec() intent.Recognizer {
	if s == nil || s.rt == nil {
		return nil
	}
	return s.rt.Rec
}

func (s *Server) engine() *coordinator.CoordinatorEngine {
	if o := s.overrides(); o != nil && o.engine != nil {
		return o.engine
	}
	if s == nil || s.rt == nil {
		return nil
	}
	return s.rt.Engine
}

func (s *Server) authSvc() *auth.Service {
	if o := s.overrides(); o != nil && o.authSvc != nil {
		return o.authSvc
	}
	if s == nil || s.rt == nil {
		return nil
	}
	return s.rt.Auth
}

func (s *Server) taskRuns() *taskrun.Manager {
	if o := s.overrides(); o != nil && o.taskRuns != nil {
		return o.taskRuns
	}
	if s == nil || s.rt == nil {
		return nil
	}
	return s.rt.TaskRuns
}

func (s *Server) authorizer() *authz.Authorizer {
	if o := s.overrides(); o != nil {
		if o.authorizerNil {
			return nil
		}
		if o.authorizer != nil {
			return o.authorizer
		}
	}
	if s == nil || s.rt == nil {
		return nil
	}
	return s.rt.Authorizer
}

func (s *Server) authzSvc() *authz.Service {
	if o := s.overrides(); o != nil && o.authzSvc != nil {
		return o.authzSvc
	}
	if s == nil || s.rt == nil {
		return nil
	}
	return s.rt.Authz
}

func (s *Server) wfDefSvc() *workflowdef.Service {
	if o := s.overrides(); o != nil && o.wfDefSvc != nil {
		return o.wfDefSvc
	}
	if s == nil || s.rt == nil {
		return nil
	}
	return s.rt.WFDef
}

func (s *Server) instSvc() *projectinstance.Service {
	if o := s.overrides(); o != nil {
		if o.instSvcNil {
			return nil
		}
		if o.instSvc != nil {
			return o.instSvc
		}
	}
	if s == nil || s.rt == nil {
		return nil
	}
	return s.rt.Inst
}

func (s *Server) notifySvc() *notification.Service {
	if o := s.overrides(); o != nil && o.notifySvc != nil {
		return o.notifySvc
	}
	if s == nil || s.rt == nil {
		return nil
	}
	return s.rt.Notify
}

func (s *Server) resolver() *workspace.Resolver {
	if o := s.overrides(); o != nil && o.resolver != nil {
		return o.resolver
	}
	if s == nil || s.rt == nil {
		return nil
	}
	return s.rt.Resolver
}

func (s *Server) wsCap() *workspace.Capability {
	if o := s.overrides(); o != nil && o.wsCap != nil {
		return o.wsCap
	}
	if s == nil || s.rt == nil {
		return nil
	}
	return s.rt.WSCap
}

func (s *Server) cmds() *taskrun.Commands {
	if o := s.overrides(); o != nil && o.cmds != nil {
		return o.cmds
	}
	if s == nil || s.rt == nil {
		return nil
	}
	return s.rt.Commands
}

func (s *Server) stageflow() *stageflow.UseCase {
	if o := s.overrides(); o != nil && o.stageflow != nil {
		return o.stageflow
	}
	if s == nil || s.rt == nil {
		return nil
	}
	return s.rt.Stageflow
}

func (s *Server) gov() *docgov.GovernanceEngine {
	if o := s.overrides(); o != nil && o.gov != nil {
		return o.gov
	}
	if s == nil || s.rt == nil {
		return nil
	}
	return s.rt.Gov
}

func (s *Server) rev() *docrevision.Service {
	if o := s.overrides(); o != nil && o.rev != nil {
		return o.rev
	}
	if s == nil || s.rt == nil {
		return nil
	}
	return s.rt.Rev
}

func (s *Server) ctxMgr() *ctxmgr.ContextManager {
	if o := s.overrides(); o != nil && o.ctxMgr != nil {
		return o.ctxMgr
	}
	if s == nil || s.rt == nil {
		return nil
	}
	return s.rt.Ctx
}

func (s *Server) cas() *storage.CAS {
	if o := s.overrides(); o != nil && o.cas != nil {
		return o.cas
	}
	if s == nil || s.rt == nil {
		return nil
	}
	return s.rt.CAS
}

func (s *Server) freeDoc() *freedoc.Service {
	if o := s.overrides(); o != nil && o.freeDoc != nil {
		return o.freeDoc
	}
	if s == nil || s.rt == nil {
		return nil
	}
	return s.rt.FreeDoc
}

func (s *Server) kb() *kb.Client {
	if o := s.overrides(); o != nil && o.kb != nil {
		return o.kb
	}
	if s == nil || s.rt == nil {
		return nil
	}
	return s.rt.KB
}

func (s *Server) sysadmin() *sysadmin.Service {
	if o := s.overrides(); o != nil && o.sysadmin != nil {
		return o.sysadmin
	}
	if s == nil || s.rt == nil {
		return nil
	}
	return s.rt.SysAdmin
}

func (s *Server) maintenance() *maintenance.Service {
	if o := s.overrides(); o != nil && o.maintenance != nil {
		return o.maintenance
	}
	if s == nil || s.rt == nil {
		return nil
	}
	return s.rt.Maintenance
}

func (s *Server) intentPlans() intentflow.Service {
	if s == nil {
		return nil
	}
	if s.intentPlansOverride != nil {
		return s.intentPlansOverride
	}
	if s.rt == nil {
		return nil
	}
	return s.rt.IntentPlans
}

// setOverride* 系列仅供测试注入替换件（serverTestOverrides）；生产代码禁止调用。

func (s *Server) setOverrideIntentPlans(v intentflow.Service) {
	if s == nil {
		return
	}
	s.intentPlansOverride = v
}

func (s *Server) setOverrideSvc(v *bizdev.Service) {
	s.ensureOverrides().svc = v
}

func (s *Server) setOverridePwSvc(v *projectworkflow.Service) {
	s.ensureOverrides().pwSvc = v
}

func (s *Server) setOverrideEngine(v *coordinator.CoordinatorEngine) {
	s.ensureOverrides().engine = v
}

func (s *Server) setOverrideAuthSvc(v *auth.Service) {
	s.ensureOverrides().authSvc = v
}

func (s *Server) setOverrideTaskRuns(v *taskrun.Manager) {
	s.ensureOverrides().taskRuns = v
}

func (s *Server) setOverrideAuthorizer(v *authz.Authorizer) {
	o := s.ensureOverrides()
	if v == nil {
		o.authorizerNil = true
		o.authorizer = nil
		return
	}
	o.authorizerNil = false
	o.authorizer = v
}

func (s *Server) setOverrideAuthzSvc(v *authz.Service) {
	s.ensureOverrides().authzSvc = v
}

func (s *Server) setOverrideWfDefSvc(v *workflowdef.Service) {
	s.ensureOverrides().wfDefSvc = v
}

func (s *Server) setOverrideInstSvc(v *projectinstance.Service) {
	o := s.ensureOverrides()
	if v == nil {
		o.instSvcNil = true
		o.instSvc = nil
		return
	}
	o.instSvcNil = false
	o.instSvc = v
}

func (s *Server) setOverrideNotifySvc(v *notification.Service) {
	s.ensureOverrides().notifySvc = v
}

func (s *Server) setOverrideResolver(v *workspace.Resolver) {
	s.ensureOverrides().resolver = v
}

func (s *Server) setOverrideWsCap(v *workspace.Capability) {
	s.ensureOverrides().wsCap = v
}

func (s *Server) setOverrideCmds(v *taskrun.Commands) {
	s.ensureOverrides().cmds = v
}

func (s *Server) setOverrideStageflow(v *stageflow.UseCase) {
	s.ensureOverrides().stageflow = v
}

func (s *Server) setOverrideGov(v *docgov.GovernanceEngine) {
	s.ensureOverrides().gov = v
}

func (s *Server) setOverrideRev(v *docrevision.Service) {
	s.ensureOverrides().rev = v
}

func (s *Server) setOverrideCtxMgr(v *ctxmgr.ContextManager) {
	s.ensureOverrides().ctxMgr = v
}

func (s *Server) setOverrideCas(v *storage.CAS) {
	s.ensureOverrides().cas = v
}

func (s *Server) setOverrideFreeDoc(v *freedoc.Service) {
	s.ensureOverrides().freeDoc = v
}

func (s *Server) setOverrideKb(v *kb.Client) {
	s.ensureOverrides().kb = v
}

func (s *Server) setOverrideSysadmin(v *sysadmin.Service) {
	s.ensureOverrides().sysadmin = v
}

func (s *Server) setOverrideMaintenance(v *maintenance.Service) {
	s.ensureOverrides().maintenance = v
}

func (s *Server) ensureOverrides() *serverTestOverrides {
	if s.testOverrides == nil {
		s.testOverrides = &serverTestOverrides{}
	}
	return s.testOverrides
}