package controllers

import (
	"fmt"
	"strconv"
	"strings"

	"server/models"
	"server/pkg/jwtutil"

	"github.com/beego/beego/v2/client/orm"
	beego "github.com/beego/beego/v2/server/web"
)

// BackendOrganizationController 组织架构（组织、员工、职位）接口。
//
// 组织架构是租户端的通用基础数据：进销存（ERP）与办公自动化（OA）两个模块各自有独立界面，
// 但读写的是同一份数据。所有查询与写入都强制带上 JWT 中的租户ID（tid），实现租户间隔离，
// 前端传入的 tid / tenant_id 一律忽略，避免越权读取其它租户的数据。
type BackendOrganizationController struct {
	beego.Controller
}

const orgSettingsCodePrefix = "backend_org_settings"

type orgSettings struct {
	OrgCodePrefix      string `json:"org_code_prefix"`
	EmployeeCodePrefix string `json:"employee_code_prefix"`
	PositionCodePrefix string `json:"position_code_prefix"`
	AutoGenerateCodes  bool   `json:"auto_generate_codes"`
	CodeLength         int    `json:"code_length"`
	DefaultOrgType     int    `json:"default_org_type"`
	DefaultSort        int    `json:"default_sort"`
	DefaultStatus      int    `json:"default_status"`
	MaxOrgLevels       int    `json:"max_org_levels"`
	MaxOrgChildren     int    `json:"max_org_children"`
	AllowDuplicateCode bool   `json:"allow_duplicate_codes"`
	BatchOperations    bool   `json:"batch_operations"`
	ExportEnabled      bool   `json:"export_enabled"`
	ImportEnabled      bool   `json:"import_enabled"`
}

func defaultOrgSettings() orgSettings {
	return orgSettings{
		OrgCodePrefix:      "ORG",
		EmployeeCodePrefix: "EMP",
		PositionCodePrefix: "POS",
		AutoGenerateCodes:  true,
		CodeLength:         8,
		DefaultOrgType:     0,
		DefaultSort:        0,
		DefaultStatus:      1,
		MaxOrgLevels:       10,
		MaxOrgChildren:     50,
		AllowDuplicateCode: false,
		BatchOperations:    true,
		ExportEnabled:      true,
		ImportEnabled:      true,
	}
}

type organizationDTO struct {
	ID            uint64 `json:"id"`
	Tid           uint64 `json:"tid"`
	TenantID      uint64 `json:"tenant_id"`
	OrgName       string `json:"org_name"`
	OrgCode       string `json:"org_code"`
	ParentID      uint64 `json:"parent_id"`
	ParentName    string `json:"parent_name"`
	LeaderID      uint64 `json:"leader_id"`
	LeaderName    string `json:"leader_name"`
	IsCompany     int    `json:"is_company"`
	Sort          uint   `json:"sort"`
	Status        int8   `json:"status"`
	Remark        string `json:"remark"`
	CreateTime    string `json:"create_time"`
	UpdateTime    string `json:"update_time"`
}

type employeeDTO struct {
	ID                uint   `json:"id"`
	Tid               int    `json:"tid"`
	TenantID          int    `json:"tenant_id"`
	Account           string `json:"account"`
	Name              string `json:"name"`
	Gender            int8   `json:"gender"`
	Sex               int8   `json:"sex"`
	Birthday          string `json:"birthday"`
	AffiliateUnit     string `json:"affiliate_unit"`
	AffiliateUnitName string `json:"affiliate_unit_name"`
	Department        string `json:"department"`
	DepartmentName    string `json:"department_name"`
	Position          string `json:"position"`
	Education         string `json:"education"`
	Nation            string `json:"nation"`
	Phone             string `json:"phone"`
	Wechat            string `json:"wechat"`
	Email             string `json:"email"`
	HomeAddress       string `json:"home_address"`
	AccountStatus     int8   `json:"account_status"`
	Status            int8   `json:"status"`
	CreateTime        string `json:"create_time"`
}

type positionDTO struct {
	ID             uint64 `json:"id"`
	Tid            uint64 `json:"tid"`
	TenantID       uint64 `json:"tenant_id"`
	DepartmentID   uint64 `json:"department_id"`
	DepartmentName string `json:"department_name"`
	PositionCode   string `json:"position_code"`
	PositionName   string `json:"position_name"`
	PositionType   int8   `json:"position_type"`
	Status         int8   `json:"status"`
	Sort           uint   `json:"sort"`
	Remark         string `json:"remark"`
	CreateTime     string `json:"create_time"`
}

// ---------------------------------------------------------------------------
// 认证与响应
// ---------------------------------------------------------------------------

// claims 解析 Authorization 头中的 JWT，要求是租户端（backend）用户且带有效租户ID。
func (c *BackendOrganizationController) claims() (*jwtutil.Claims, bool) {
	auth := strings.TrimSpace(c.Ctx.Request.Header.Get("Authorization"))
	parts := strings.SplitN(auth, " ", 2)
	if len(parts) != 2 || parts[0] != "Bearer" {
		return nil, false
	}
	claims, err := jwtutil.ParseToken(parts[1])
	if err != nil || claims.UserType != "backend" || claims.TenantId <= 0 {
		return nil, false
	}
	return claims, true
}

// tenantID 取当前登录租户ID，未通过认证时直接输出 401 并返回 false。
func (c *BackendOrganizationController) tenantID() (uint64, bool) {
	claims, ok := c.claims()
	if !ok {
		c.jsonError(401, "未登录或登录已过期")
		return 0, false
	}
	return uint64(claims.TenantId), true
}

func (c *BackendOrganizationController) jsonOK(data interface{}) {
	resp := map[string]interface{}{"code": 200, "msg": "success"}
	if data != nil {
		resp["data"] = data
	}
	c.Data["json"] = resp
	_ = c.ServeJSON()
}

func (c *BackendOrganizationController) jsonError(code int, msg string) {
	if code == 401 {
		c.Ctx.Output.SetStatus(401)
	}
	c.Data["json"] = map[string]interface{}{"code": code, "msg": msg}
	_ = c.ServeJSON()
}

// ---------------------------------------------------------------------------
// 查询基座：所有 QuerySeter 都强制附加 tid 过滤
// ---------------------------------------------------------------------------

func (c *BackendOrganizationController) orgQuery(tid uint64) orm.QuerySeter {
	return models.Orm.QueryTable(new(models.BackendOrganization)).
		Filter("tid", tid).
		Filter("delete_time__isnull", true)
}

func (c *BackendOrganizationController) employeeQuery(tid uint64) orm.QuerySeter {
	return models.Orm.QueryTable(new(models.BackendEmployee)).
		Filter("tid", tid).
		Filter("delete_time__isnull", true)
}

func (c *BackendOrganizationController) positionQuery(tid uint64) orm.QuerySeter {
	return models.Orm.QueryTable(new(models.BackendPosition)).
		Filter("tid", tid).
		Filter("delete_time__isnull", true)
}

// ---------------------------------------------------------------------------
// 组织机构
// ---------------------------------------------------------------------------

// GetOrganization 获取组织机构列表（扁平）。
// GET /backend/{erp|oa}/getOrganization
func (c *BackendOrganizationController) GetOrganization() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}

	qs := c.orgQuery(tid).Exclude("status", 0)
	if keyword := strings.TrimSpace(c.GetString("keyword")); keyword != "" {
		qs = qs.Filter("org_name__icontains", keyword)
	}

	var rows []models.BackendOrganization
	if _, err := qs.OrderBy("sort", "id").All(&rows); err != nil {
		c.jsonError(500, "查询组织机构失败: "+err.Error())
		return
	}

	c.jsonOK(c.organizationDTOList(tid, rows))
}

// GetOrganizationDetail 获取组织机构详情。
// GET /backend/{erp|oa}/getOrganizationDetail/:id
func (c *BackendOrganizationController) GetOrganizationDetail() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}
	id, valid := c.pathUint64(":id")
	if !valid {
		c.jsonError(400, "无效ID")
		return
	}

	var row models.BackendOrganization
	if err := c.orgQuery(tid).Filter("id", id).Exclude("status", 0).One(&row); err != nil {
		c.jsonError(404, "组织机构不存在")
		return
	}

	c.jsonOK(c.organizationDTO(tid, row))
}

// CreateOrganization 创建组织机构。
// POST /backend/{erp|oa}/createOrganization
func (c *BackendOrganizationController) CreateOrganization() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}
	body := c.parseJSONBody()
	settings := c.loadOrgSettings(tid)

	orgName, _ := c.getStringValue(body, "org_name", "name")
	orgName = strings.TrimSpace(orgName)
	if orgName == "" {
		c.jsonError(400, "组织名称不能为空")
		return
	}

	parentID, _ := c.getUint64Value(body, "parent_id")
	if parentID > 0 {
		if !c.orgExists(tid, parentID) {
			c.jsonError(400, "上级组织不存在")
			return
		}
		depth, err := c.orgDepth(tid, parentID)
		if err != nil {
			c.jsonError(500, "校验组织层级失败: "+err.Error())
			return
		}
		if settings.MaxOrgLevels > 0 && depth+1 > settings.MaxOrgLevels {
			c.jsonError(400, fmt.Sprintf("组织层级最多 %d 级", settings.MaxOrgLevels))
			return
		}
		if settings.MaxOrgChildren > 0 {
			count, err := c.orgQuery(tid).Filter("parent_id", parentID).Exclude("status", 0).Count()
			if err == nil && int(count) >= settings.MaxOrgChildren {
				c.jsonError(400, fmt.Sprintf("同一上级下最多 %d 个子组织", settings.MaxOrgChildren))
				return
			}
		}
	}

	orgCode, _ := c.getStringValue(body, "org_code", "code")
	orgCode = strings.TrimSpace(orgCode)
	if orgCode == "" {
		if !settings.AutoGenerateCodes {
			c.jsonError(400, "组织编码不能为空")
			return
		}
		orgCode = c.generateCode(settings.OrgCodePrefix, settings.CodeLength)
	}
	if !settings.AllowDuplicateCode {
		count, err := c.orgQuery(tid).Filter("org_code", orgCode).Count()
		if err != nil {
			c.jsonError(500, "校验组织编码失败: "+err.Error())
			return
		}
		if count > 0 {
			c.jsonError(400, "组织编码已存在")
			return
		}
	}

	leaderID, hasLeader := c.getUint64Value(body, "leader_id")
	sortVal, hasSort := c.getUintValue(body, "sort")
	isCompany, hasCompany := c.getIntValue(body, "is_company")
	status, hasStatus := c.getIntValue(body, "status")
	remark, _ := c.getStringValue(body, "remark")

	row := models.BackendOrganization{
		Tid:       tid,
		OrgName:   orgName,
		OrgCode:   orgCode,
		ParentID:  parentID,
		Sort:      uint(settings.DefaultSort),
		IsCompany: boolInt(parentID == 0),
		Status:    int8(settings.DefaultStatus),
		Remark:    strPtrIfNotEmpty(remark),
	}
	if hasSort {
		row.Sort = sortVal
	}
	if hasLeader && leaderID > 0 {
		row.LeaderID = &leaderID
	}
	if hasCompany {
		row.IsCompany = isCompany
	}
	if hasStatus {
		row.Status = int8(status)
	}

	id, err := models.Orm.Insert(&row)
	if err != nil {
		c.jsonError(500, "创建组织机构失败: "+err.Error())
		return
	}

	c.jsonOK(map[string]interface{}{"id": id, "org_code": orgCode})
}

// EditOrganization 更新组织机构。
// POST /backend/{erp|oa}/editOrganization/:id
func (c *BackendOrganizationController) EditOrganization() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}
	id, valid := c.pathUint64(":id")
	if !valid {
		c.jsonError(400, "无效ID")
		return
	}
	if !c.orgExists(tid, id) {
		c.jsonError(404, "组织机构不存在")
		return
	}

	body := c.parseJSONBody()
	settings := c.loadOrgSettings(tid)
	update := orm.Params{}

	if v, has := c.getStringValue(body, "org_name", "name"); has {
		v = strings.TrimSpace(v)
		if v == "" {
			c.jsonError(400, "组织名称不能为空")
			return
		}
		update["org_name"] = v
	}
	if v, has := c.getStringValue(body, "org_code", "code"); has {
		v = strings.TrimSpace(v)
		if v == "" {
			c.jsonError(400, "组织编码不能为空")
			return
		}
		if !settings.AllowDuplicateCode {
			count, err := c.orgQuery(tid).Filter("org_code", v).Exclude("id", id).Count()
			if err != nil {
				c.jsonError(500, "校验组织编码失败: "+err.Error())
				return
			}
			if count > 0 {
				c.jsonError(400, "组织编码已存在")
				return
			}
		}
		update["org_code"] = v
	}
	if v, has := c.getUint64Value(body, "parent_id"); has {
		if err := c.validateParentChange(tid, id, v, settings); err != nil {
			c.jsonError(400, err.Error())
			return
		}
		update["parent_id"] = v
	}
	if v, has := c.getUint64Value(body, "leader_id"); has {
		update["leader_id"] = nullableUint64(v)
	}
	if v, has := c.getUintValue(body, "sort"); has {
		update["sort"] = v
	}
	if v, has := c.getIntValue(body, "is_company"); has {
		update["is_company"] = v
	}
	if v, has := c.getIntValue(body, "status"); has {
		update["status"] = int8(v)
	}
	if v, has := c.getStringValue(body, "remark"); has {
		update["remark"] = nullableString(v)
	}

	if len(update) == 0 {
		c.jsonError(400, "无更新字段")
		return
	}

	if _, err := c.orgQuery(tid).Filter("id", id).Update(update); err != nil {
		c.jsonError(500, "更新组织机构失败: "+err.Error())
		return
	}

	c.jsonOK(nil)
}

// DeleteOrganization 删除组织机构（软删除）。
// DELETE /backend/{erp|oa}/deleteOrganization/:id
func (c *BackendOrganizationController) DeleteOrganization() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}
	id, valid := c.pathUint64(":id")
	if !valid {
		c.jsonError(400, "无效ID")
		return
	}

	childCount, err := c.orgQuery(tid).Filter("parent_id", id).Exclude("status", 0).Count()
	if err != nil {
		c.jsonError(500, "检查子组织失败: "+err.Error())
		return
	}
	if childCount > 0 {
		c.jsonError(400, "请先删除下级组织")
		return
	}

	employeeCount, err := c.employeeQuery(tid).Filter("department", strconv.FormatUint(id, 10)).Count()
	if err != nil {
		c.jsonError(500, "检查组织员工失败: "+err.Error())
		return
	}
	if employeeCount > 0 {
		c.jsonError(400, "该组织下还有员工，请先调岗或删除员工")
		return
	}

	num, err := c.orgQuery(tid).Filter("id", id).
		Update(orm.Params{"delete_time": c.nowString(), "status": int8(0)})
	if err != nil {
		c.jsonError(500, "删除组织机构失败: "+err.Error())
		return
	}
	if num == 0 {
		c.jsonError(404, "组织机构不存在")
		return
	}

	c.jsonOK(nil)
}

// GetCompanys 获取企业单位列表。
// GET /backend/{erp|oa}/getCompanys
func (c *BackendOrganizationController) GetCompanys() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}

	var rows []models.BackendOrganization
	_, err := c.orgQuery(tid).Exclude("status", 0).Filter("is_company", 1).
		OrderBy("sort", "id").All(&rows)
	if err != nil {
		c.jsonError(500, "查询企业单位失败: "+err.Error())
		return
	}

	c.jsonOK(c.organizationDTOList(tid, rows))
}

// GetDepartments 获取部门列表。
// GET /backend/{erp|oa}/getDepartments?parent_id=1
func (c *BackendOrganizationController) GetDepartments() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}
	parentID, _ := c.GetUint64("parent_id")

	qs := c.orgQuery(tid).Exclude("status", 0)
	if parentID > 0 {
		qs = qs.Filter("parent_id", parentID)
	} else {
		qs = qs.Filter("is_company", 0)
	}

	var rows []models.BackendOrganization
	if _, err := qs.OrderBy("sort", "id").All(&rows); err != nil {
		c.jsonError(500, "查询部门失败: "+err.Error())
		return
	}

	c.jsonOK(c.organizationDTOList(tid, rows))
}

// GetOrganizationTree 获取组织架构树。
// GET /backend/{erp|oa}/getOrganizationTree
func (c *BackendOrganizationController) GetOrganizationTree() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}

	var rows []models.BackendOrganization
	_, err := c.orgQuery(tid).Exclude("status", 0).OrderBy("sort", "id").All(&rows)
	if err != nil {
		c.jsonError(500, "查询组织机构失败: "+err.Error())
		return
	}

	c.jsonOK(buildOrganizationTree(c.organizationDTOList(tid, rows)))
}

// SearchOrganizations 按名称/编码搜索组织机构。
// GET /backend/{erp|oa}/searchOrganizations?keyword=xx
func (c *BackendOrganizationController) SearchOrganizations() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}
	keyword := strings.TrimSpace(c.GetString("keyword"))

	cond := orm.NewCondition().
		And("tid", tid).
		And("delete_time__isnull", true).
		AndNot("status", 0)
	if keyword != "" {
		cond = cond.AndCond(orm.NewCondition().
			Or("org_name__icontains", keyword).
			Or("org_code__icontains", keyword))
	}

	var rows []models.BackendOrganization
	_, err := models.Orm.QueryTable(new(models.BackendOrganization)).
		SetCond(cond).OrderBy("sort", "id").All(&rows)
	if err != nil {
		c.jsonError(500, "查询组织机构失败: "+err.Error())
		return
	}

	c.jsonOK(c.organizationDTOList(tid, rows))
}

// GetOrganizationHierarchy 获取指定组织的上级链与直接下级。
// GET /backend/{erp|oa}/getOrganizationHierarchy/:org_id
func (c *BackendOrganizationController) GetOrganizationHierarchy() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}
	orgID, valid := c.pathUint64(":org_id")
	if !valid {
		c.jsonError(400, "无效组织ID")
		return
	}

	var org models.BackendOrganization
	if err := c.orgQuery(tid).Filter("id", orgID).One(&org); err != nil {
		c.jsonError(404, "组织不存在")
		return
	}

	var children []models.BackendOrganization
	if _, err := c.orgQuery(tid).Filter("parent_id", orgID).Exclude("status", 0).
		OrderBy("sort", "id").All(&children); err != nil {
		c.jsonError(500, "查询子组织失败: "+err.Error())
		return
	}

	// 自底向上收集上级链，最多回溯 64 层，防止脏数据造成死循环
	ancestors := make([]organizationDTO, 0)
	parentID := org.ParentID
	for i := 0; i < 64 && parentID > 0; i++ {
		var parent models.BackendOrganization
		if err := c.orgQuery(tid).Filter("id", parentID).One(&parent); err != nil {
			break
		}
		ancestors = append([]organizationDTO{c.organizationDTO(tid, parent)}, ancestors...)
		parentID = parent.ParentID
	}

	c.jsonOK(map[string]interface{}{
		"current":   c.organizationDTO(tid, org),
		"ancestors": ancestors,
		"children":  c.organizationDTOList(tid, children),
	})
}

// GetOrganizationStats 组织架构统计。
// GET /backend/{erp|oa}/getOrganizationStats
func (c *BackendOrganizationController) GetOrganizationStats() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}

	var rows []models.BackendOrganization
	if _, err := c.orgQuery(tid).All(&rows); err != nil {
		c.jsonError(500, "统计组织架构失败: "+err.Error())
		return
	}

	childrenOf := map[uint64][]uint64{}
	for _, row := range rows {
		childrenOf[row.ParentID] = append(childrenOf[row.ParentID], row.ID)
	}

	companyCount, departmentCount, enabledCount := 0, 0, 0
	for _, row := range rows {
		if row.IsCompany == 1 {
			companyCount++
		} else {
			departmentCount++
		}
		if row.Status == 1 {
			enabledCount++
		}
	}

	employeeTotal, _ := c.employeeQuery(tid).Count()
	employeeActive, _ := c.employeeQuery(tid).Filter("account_status", 1).Count()
	positionTotal, _ := c.positionQuery(tid).Count()

	c.jsonOK(map[string]interface{}{
		"org_total":        len(rows),
		"company_count":    companyCount,
		"department_count": departmentCount,
		"enabled_count":    enabledCount,
		"disabled_count":   len(rows) - enabledCount,
		"max_depth":        treeDepth(childrenOf, 0, 0),
		"employee_total":   employeeTotal,
		"employee_active":  employeeActive,
		"position_total":   positionTotal,
	})
}

// MoveOrganization 移动组织节点到新的上级（拖拽调整层级）。
// POST /backend/{erp|oa}/moveOrganization
func (c *BackendOrganizationController) MoveOrganization() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}
	body := c.parseJSONBody()

	orgID, hasOrg := c.getUint64Value(body, "org_id", "id")
	if !hasOrg || orgID == 0 {
		c.jsonError(400, "组织ID不能为空")
		return
	}
	parentID, _ := c.getUint64Value(body, "parent_id")

	if !c.orgExists(tid, orgID) {
		c.jsonError(404, "组织不存在")
		return
	}
	settings := c.loadOrgSettings(tid)
	if err := c.validateParentChange(tid, orgID, parentID, settings); err != nil {
		c.jsonError(400, err.Error())
		return
	}

	update := orm.Params{"parent_id": parentID, "is_company": boolInt(parentID == 0)}
	if v, has := c.getUintValue(body, "sort"); has {
		update["sort"] = v
	}
	if _, err := c.orgQuery(tid).Filter("id", orgID).Update(update); err != nil {
		c.jsonError(500, "移动组织失败: "+err.Error())
		return
	}

	c.jsonOK(nil)
}

// BatchOrganizeOrganizations 批量启用/禁用/删除组织。
// POST /backend/{erp|oa}/batchOrganizeOrganizations
func (c *BackendOrganizationController) BatchOrganizeOrganizations() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}
	body := c.parseJSONBody()

	ids := c.getUint64Slice(body, "ids")
	if len(ids) == 0 {
		c.jsonError(400, "请选择要操作的组织")
		return
	}
	action, _ := c.getStringValue(body, "action")
	action = strings.ToLower(strings.TrimSpace(action))

	var update orm.Params
	switch action {
	case "enable":
		update = orm.Params{"status": int8(1)}
	case "disable":
		update = orm.Params{"status": int8(0)}
	case "delete":
		// 有下级或有员工的组织不允许批量删除，避免产生孤儿数据
		for _, id := range ids {
			childCount, _ := c.orgQuery(tid).Filter("parent_id", id).Exclude("status", 0).Count()
			if childCount > 0 {
				c.jsonError(400, "选中组织存在下级组织，无法批量删除")
				return
			}
			employeeCount, _ := c.employeeQuery(tid).Filter("department", strconv.FormatUint(id, 10)).Count()
			if employeeCount > 0 {
				c.jsonError(400, "选中组织下仍有员工，无法批量删除")
				return
			}
		}
		update = orm.Params{"delete_time": c.nowString(), "status": int8(0)}
	default:
		c.jsonError(400, "不支持的操作类型")
		return
	}

	num, err := c.orgQuery(tid).Filter("id__in", ids).Update(update)
	if err != nil {
		c.jsonError(500, "批量操作失败: "+err.Error())
		return
	}

	c.jsonOK(map[string]interface{}{"affected": num})
}

// CheckOrgCodeUnique 检查组织编码唯一性。
// GET /backend/{erp|oa}/checkOrgCodeUnique?org_code=xx&exclude_id=1
func (c *BackendOrganizationController) CheckOrgCodeUnique() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}
	orgCode := strings.TrimSpace(c.GetString("org_code"))
	if orgCode == "" {
		c.jsonError(400, "组织编码不能为空")
		return
	}
	excludeID, _ := c.GetUint64("exclude_id")
	if excludeID == 0 {
		excludeID, _ = c.GetUint64("org_id")
	}

	qs := c.orgQuery(tid).Filter("org_code", orgCode)
	if excludeID > 0 {
		qs = qs.Exclude("id", excludeID)
	}

	count, err := qs.Count()
	if err != nil {
		c.jsonError(500, "检查编码唯一性失败: "+err.Error())
		return
	}

	c.jsonOK(map[string]interface{}{"unique": count == 0, "message": uniqueMessage(count == 0, "编码")})
}

// ---------------------------------------------------------------------------
// 员工
// ---------------------------------------------------------------------------

// GetEmployee 获取员工列表，支持按组织、关键词、状态过滤。
// GET /backend/{erp|oa}/getEmployee?org_id=1&keyword=xx&status=1
func (c *BackendOrganizationController) GetEmployee() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}

	cond := orm.NewCondition().And("tid", tid).And("delete_time__isnull", true)

	orgID, _ := c.GetUint64("org_id")
	if orgID == 0 {
		orgID, _ = c.GetUint64("department_id")
	}
	if orgID > 0 {
		// 含下级组织：把整棵子树的组织ID都算进去
		orgIDs := c.collectOrgIDs(tid, orgID)
		values := make([]string, 0, len(orgIDs))
		for _, id := range orgIDs {
			values = append(values, strconv.FormatUint(id, 10))
		}
		cond = cond.And("department__in", values)
	}
	if keyword := strings.TrimSpace(c.GetString("keyword")); keyword != "" {
		cond = cond.AndCond(orm.NewCondition().
			Or("name__icontains", keyword).
			Or("account__icontains", keyword).
			Or("phone__icontains", keyword))
	}
	if raw := strings.TrimSpace(c.GetString("status")); raw != "" {
		if status, err := strconv.Atoi(raw); err == nil {
			cond = cond.And("account_status", int8(status))
		}
	}

	var rows []models.BackendEmployee
	_, err := models.Orm.QueryTable(new(models.BackendEmployee)).
		SetCond(cond).OrderBy("-id").All(&rows)
	if err != nil {
		c.jsonError(500, "查询员工失败: "+err.Error())
		return
	}

	c.jsonOK(c.employeeDTOList(tid, rows))
}

// GetOrganizationEmployees 获取指定组织（含下级）的员工列表。
// GET /backend/{erp|oa}/getOrganizationEmployees/:org_id
func (c *BackendOrganizationController) GetOrganizationEmployees() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}
	orgID, valid := c.pathUint64(":org_id")
	if !valid {
		c.jsonError(400, "无效组织ID")
		return
	}

	orgIDs := c.collectOrgIDs(tid, orgID)
	values := make([]string, 0, len(orgIDs))
	for _, id := range orgIDs {
		values = append(values, strconv.FormatUint(id, 10))
	}

	var rows []models.BackendEmployee
	_, err := c.employeeQuery(tid).Filter("department__in", values).OrderBy("-id").All(&rows)
	if err != nil {
		c.jsonError(500, "查询员工失败: "+err.Error())
		return
	}

	c.jsonOK(c.employeeDTOList(tid, rows))
}

// GetEmployeeDetail 获取员工详情。
// GET /backend/{erp|oa}/getEmployeeDetail/:id
func (c *BackendOrganizationController) GetEmployeeDetail() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}
	id, valid := c.pathUint(":id")
	if !valid {
		c.jsonError(400, "无效ID")
		return
	}

	var row models.BackendEmployee
	if err := c.employeeQuery(tid).Filter("id", id).One(&row); err != nil {
		c.jsonError(404, "员工不存在")
		return
	}

	c.jsonOK(c.employeeDTO(tid, row))
}

// CreateEmployee 创建员工。
// POST /backend/{erp|oa}/createEmployee
func (c *BackendOrganizationController) CreateEmployee() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}
	body := c.parseJSONBody()
	settings := c.loadOrgSettings(tid)

	name, _ := c.getStringValue(body, "name")
	name = strings.TrimSpace(name)
	if name == "" {
		c.jsonError(400, "姓名不能为空")
		return
	}

	account, _ := c.getStringValue(body, "account")
	account = strings.TrimSpace(account)
	if account == "" {
		if !settings.AutoGenerateCodes {
			c.jsonError(400, "账号不能为空")
			return
		}
		account = c.generateCode(settings.EmployeeCodePrefix, settings.CodeLength)
	}
	count, err := c.employeeQuery(tid).Filter("account", account).Count()
	if err != nil {
		c.jsonError(500, "校验账号失败: "+err.Error())
		return
	}
	if count > 0 {
		c.jsonError(400, "账号已存在")
		return
	}

	gender, hasGender := c.getIntValue(body, "gender", "sex")
	status, hasStatus := c.getIntValue(body, "account_status", "status")
	password, _ := c.getStringValue(body, "password")
	birthday, _ := c.getStringValue(body, "birthday")
	affiliateUnit, _ := c.getStringValue(body, "affiliate_unit")
	department, _ := c.getStringValue(body, "department")
	position, _ := c.getStringValue(body, "position")
	education, _ := c.getStringValue(body, "education")
	nation, _ := c.getStringValue(body, "nation")
	phone, _ := c.getStringValue(body, "phone")
	wechat, _ := c.getStringValue(body, "wechat")
	email, _ := c.getStringValue(body, "email")
	homeAddress, _ := c.getStringValue(body, "home_address")

	if err := c.validateEmployeeOrg(tid, affiliateUnit, department); err != nil {
		c.jsonError(400, err.Error())
		return
	}

	tidInt := int(tid)
	row := models.BackendEmployee{
		Tid:           &tidInt,
		Account:       account,
		Password:      hashEmployeePassword(password),
		Name:          name,
		Gender:        0,
		Birthday:      parseDatePtr(birthday),
		AffiliateUnit: strPtrIfNotEmpty(affiliateUnit),
		Department:    strPtrIfNotEmpty(department),
		Position:      strPtrIfNotEmpty(position),
		Education:     strPtrIfNotEmpty(education),
		Nation:        strPtrIfNotEmpty(nation),
		Phone:         strPtrIfNotEmpty(phone),
		Wechat:        strPtrIfNotEmpty(wechat),
		Email:         strPtrIfNotEmpty(email),
		HomeAddress:   strPtrIfNotEmpty(homeAddress),
		AccountStatus: 1,
	}
	if hasGender {
		row.Gender = int8(gender)
	}
	if hasStatus {
		row.AccountStatus = int8(status)
	}

	id, err := models.Orm.Insert(&row)
	if err != nil {
		c.jsonError(500, "创建员工失败: "+err.Error())
		return
	}

	// 同步到通讯录（员工为基础数据，已建档时档案字段优先）
	SyncContactOnEmployeeCreate(tid, uint64(id), &row)

	c.jsonOK(map[string]interface{}{"id": id, "account": account})
}

// EditEmployee 更新员工。
// POST /backend/{erp|oa}/editEmployee/:id
func (c *BackendOrganizationController) EditEmployee() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}
	id, valid := c.pathUint(":id")
	if !valid {
		c.jsonError(400, "无效ID")
		return
	}

	if !c.employeeQuery(tid).Filter("id", id).Exist() {
		c.jsonError(404, "员工不存在")
		return
	}

	body := c.parseJSONBody()
	update := orm.Params{}

	if v, has := c.getStringValue(body, "account"); has && strings.TrimSpace(v) != "" {
		v = strings.TrimSpace(v)
		count, err := c.employeeQuery(tid).Filter("account", v).Exclude("id", id).Count()
		if err != nil {
			c.jsonError(500, "校验账号失败: "+err.Error())
			return
		}
		if count > 0 {
			c.jsonError(400, "账号已存在")
			return
		}
		update["account"] = v
	}
	if v, has := c.getStringValue(body, "name"); has {
		v = strings.TrimSpace(v)
		if v == "" {
			c.jsonError(400, "姓名不能为空")
			return
		}
		update["name"] = v
	}
	if v, has := c.getIntValue(body, "gender", "sex"); has {
		update["gender"] = int8(v)
	}
	if v, has := c.getStringValue(body, "birthday"); has {
		update["birthday"] = parseDatePtr(v)
	}

	affiliateUnit, hasAffiliate := c.getStringValue(body, "affiliate_unit")
	department, hasDepartment := c.getStringValue(body, "department")
	if hasAffiliate || hasDepartment {
		if err := c.validateEmployeeOrg(tid, affiliateUnit, department); err != nil {
			c.jsonError(400, err.Error())
			return
		}
	}
	if hasAffiliate {
		update["affiliate_unit"] = nullableString(affiliateUnit)
	}
	if hasDepartment {
		update["department"] = nullableString(department)
	}

	if v, has := c.getStringValue(body, "position"); has {
		update["position"] = nullableString(v)
	}
	if v, has := c.getStringValue(body, "education"); has {
		update["education"] = nullableString(v)
	}
	if v, has := c.getStringValue(body, "nation"); has {
		update["nation"] = nullableString(v)
	}
	if v, has := c.getStringValue(body, "phone"); has {
		update["phone"] = nullableString(v)
	}
	if v, has := c.getStringValue(body, "wechat"); has {
		update["wechat"] = nullableString(v)
	}
	if v, has := c.getStringValue(body, "email"); has {
		update["email"] = nullableString(v)
	}
	if v, has := c.getStringValue(body, "home_address"); has {
		update["home_address"] = nullableString(v)
	}
	if v, has := c.getIntValue(body, "account_status", "status"); has {
		update["account_status"] = int8(v)
	}
	if v, has := c.getStringValue(body, "password"); has && strings.TrimSpace(v) != "" {
		update["password"] = hashEmployeePassword(v)
	}

	if len(update) == 0 {
		c.jsonError(400, "无更新字段")
		return
	}

	if _, err := c.employeeQuery(tid).Filter("id", id).Update(update); err != nil {
		c.jsonError(500, "更新员工失败: "+err.Error())
		return
	}

	// 同步到通讯录（字段优先级：人事档案 > 员工）
	SyncContactOnEmployeeRefresh(tid, uint64(id))

	c.jsonOK(nil)
}

// DeleteEmployee 员工离职/禁用：员工不做删除，只改账号状态。
//
// 说明：员工属于企业数据，人事档案（yz_backend_employee_file）与通讯录
//（yz_backend_erp_contact）都以 employee_id 关联员工。一旦把员工软删除（写 delete_time），
// 档案页与通讯录就查不到对应的人，等于连带删掉了企业数据。
// 因此这里只把账号状态置为"离职"（2），不写 delete_time，也不触碰档案与通讯录记录。
// 启用/禁用请走 editEmployee 改 account_status（1 启用 / 0 禁用 / 2 离职）。
// DELETE /backend/{erp|oa}/deleteEmployee/:id
func (c *BackendOrganizationController) DeleteEmployee() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}
	id, valid := c.pathUint(":id")
	if !valid {
		c.jsonError(400, "无效ID")
		return
	}

	if !c.employeeQuery(tid).Filter("id", id).Exist() {
		c.jsonError(404, "员工不存在")
		return
	}

	// 员工不允许删除，仅置为离职状态；档案与通讯录原样保留
	if _, err := c.employeeQuery(tid).Filter("id", id).
		Update(orm.Params{"account_status": int8(2)}); err != nil {
		c.jsonError(500, "离职操作失败: "+err.Error())
		return
	}

	c.jsonOK(nil)
}

// MoveEmployeeToOrg 员工调岗：批量或单个移动到指定组织。
// POST /backend/{erp|oa}/moveEmployeeToOrg
func (c *BackendOrganizationController) MoveEmployeeToOrg() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}
	body := c.parseJSONBody()

	orgID, hasOrg := c.getUint64Value(body, "org_id", "department_id")
	if !hasOrg || orgID == 0 {
		c.jsonError(400, "组织ID不能为空")
		return
	}

	ids := c.getUintSlice(body, "employee_ids", "ids")
	if single, has := c.getUintValue(body, "employee_id"); has && single > 0 {
		ids = append(ids, single)
	}
	if len(ids) == 0 {
		c.jsonError(400, "请选择要调岗的员工")
		return
	}

	var org models.BackendOrganization
	if err := c.orgQuery(tid).Filter("id", orgID).One(&org); err != nil {
		c.jsonError(400, "目标组织不存在")
		return
	}

	update := orm.Params{"department": strconv.FormatUint(orgID, 10)}
	// 部门变更时同步隶属单位：取该组织所在的顶层公司
	if companyID := c.rootCompanyID(tid, org); companyID > 0 {
		update["affiliate_unit"] = strconv.FormatUint(companyID, 10)
	}
	if v, has := c.getStringValue(body, "position"); has {
		update["position"] = nullableString(v)
	}

	num, err := c.employeeQuery(tid).Filter("id__in", ids).Update(update)
	if err != nil {
		c.jsonError(500, "调岗失败: "+err.Error())
		return
	}
	if num == 0 {
		c.jsonError(404, "员工不存在")
		return
	}

	c.jsonOK(map[string]interface{}{"affected": num})
}

// CheckEmployeeAccountUnique 检查员工账号唯一性。
// GET /backend/{erp|oa}/checkEmployeeAccountUnique?account=xx&exclude_id=1
func (c *BackendOrganizationController) CheckEmployeeAccountUnique() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}
	account := strings.TrimSpace(c.GetString("account"))
	if account == "" {
		c.jsonError(400, "员工账号不能为空")
		return
	}
	excludeID, _ := c.GetUint64("exclude_id")
	if excludeID == 0 {
		excludeID, _ = c.GetUint64("employee_id")
	}

	qs := c.employeeQuery(tid).Filter("account", account)
	if excludeID > 0 {
		qs = qs.Exclude("id", excludeID)
	}

	count, err := qs.Count()
	if err != nil {
		c.jsonError(500, "检查账号唯一性失败: "+err.Error())
		return
	}

	c.jsonOK(map[string]interface{}{"unique": count == 0, "message": uniqueMessage(count == 0, "账号")})
}

// ---------------------------------------------------------------------------
// 职位
// ---------------------------------------------------------------------------

// GetPosition 获取职位列表。
// GET /backend/{erp|oa}/getPosition?department_id=1&keyword=xx
func (c *BackendOrganizationController) GetPosition() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}

	cond := orm.NewCondition().And("tid", tid).And("delete_time__isnull", true)
	if departmentID, _ := c.GetUint64("department_id"); departmentID > 0 {
		cond = cond.And("department_id", departmentID)
	}
	if keyword := strings.TrimSpace(c.GetString("keyword")); keyword != "" {
		cond = cond.AndCond(orm.NewCondition().
			Or("position_name__icontains", keyword).
			Or("position_code__icontains", keyword))
	}
	if raw := strings.TrimSpace(c.GetString("status")); raw != "" {
		if status, err := strconv.Atoi(raw); err == nil {
			cond = cond.And("status", int8(status))
		}
	}

	var rows []models.BackendPosition
	_, err := models.Orm.QueryTable(new(models.BackendPosition)).
		SetCond(cond).OrderBy("sort", "id").All(&rows)
	if err != nil {
		c.jsonError(500, "查询职位失败: "+err.Error())
		return
	}

	list := make([]positionDTO, 0, len(rows))
	for _, row := range rows {
		list = append(list, c.positionDTO(tid, row))
	}

	c.jsonOK(list)
}

// GetPositionDetail 获取职位详情。
// GET /backend/{erp|oa}/getPositionDetail/:id
func (c *BackendOrganizationController) GetPositionDetail() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}
	id, valid := c.pathUint64(":id")
	if !valid {
		c.jsonError(400, "无效ID")
		return
	}

	var row models.BackendPosition
	if err := c.positionQuery(tid).Filter("id", id).One(&row); err != nil {
		c.jsonError(404, "职位不存在")
		return
	}

	c.jsonOK(c.positionDTO(tid, row))
}

// CreatePosition 创建职位。
// POST /backend/{erp|oa}/createPosition
func (c *BackendOrganizationController) CreatePosition() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}
	body := c.parseJSONBody()
	settings := c.loadOrgSettings(tid)

	positionName, _ := c.getStringValue(body, "position_name", "name")
	positionName = strings.TrimSpace(positionName)
	if positionName == "" {
		c.jsonError(400, "职位名称不能为空")
		return
	}

	departmentID, _ := c.getUint64Value(body, "department_id")
	if departmentID > 0 && !c.orgExists(tid, departmentID) {
		c.jsonError(400, "所属部门不存在")
		return
	}

	positionCode, _ := c.getStringValue(body, "position_code", "code")
	positionCode = strings.TrimSpace(positionCode)
	if positionCode == "" {
		if !settings.AutoGenerateCodes {
			c.jsonError(400, "职位编码不能为空")
			return
		}
		positionCode = c.generateCode(settings.PositionCodePrefix, settings.CodeLength)
	}
	if !settings.AllowDuplicateCode {
		count, err := c.positionQuery(tid).Filter("position_code", positionCode).Count()
		if err != nil {
			c.jsonError(500, "校验职位编码失败: "+err.Error())
			return
		}
		if count > 0 {
			c.jsonError(400, "职位编码已存在")
			return
		}
	}

	positionType, _ := c.getIntValue(body, "position_type")
	status, hasStatus := c.getIntValue(body, "status")
	sortVal, _ := c.getUintValue(body, "sort")
	remark, _ := c.getStringValue(body, "remark")

	row := models.BackendPosition{
		Tid:          tid,
		DepartmentID: departmentID,
		PositionCode: positionCode,
		PositionName: positionName,
		PositionType: int8(positionType),
		Status:       1,
		Sort:         sortVal,
		Remark:       strPtrIfNotEmpty(remark),
	}
	if hasStatus {
		row.Status = int8(status)
	}

	id, err := models.Orm.Insert(&row)
	if err != nil {
		c.jsonError(500, "创建职位失败: "+err.Error())
		return
	}

	c.jsonOK(map[string]interface{}{"id": id, "position_code": positionCode})
}

// EditPosition 更新职位。
// POST /backend/{erp|oa}/editPosition/:id
func (c *BackendOrganizationController) EditPosition() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}
	id, valid := c.pathUint64(":id")
	if !valid {
		c.jsonError(400, "无效ID")
		return
	}
	if !c.positionQuery(tid).Filter("id", id).Exist() {
		c.jsonError(404, "职位不存在")
		return
	}

	body := c.parseJSONBody()
	settings := c.loadOrgSettings(tid)
	update := orm.Params{}

	if v, has := c.getUint64Value(body, "department_id"); has {
		if v > 0 && !c.orgExists(tid, v) {
			c.jsonError(400, "所属部门不存在")
			return
		}
		update["department_id"] = v
	}
	if v, has := c.getStringValue(body, "position_code", "code"); has {
		v = strings.TrimSpace(v)
		if v == "" {
			c.jsonError(400, "职位编码不能为空")
			return
		}
		if !settings.AllowDuplicateCode {
			count, err := c.positionQuery(tid).Filter("position_code", v).Exclude("id", id).Count()
			if err != nil {
				c.jsonError(500, "校验职位编码失败: "+err.Error())
				return
			}
			if count > 0 {
				c.jsonError(400, "职位编码已存在")
				return
			}
		}
		update["position_code"] = v
	}
	if v, has := c.getStringValue(body, "position_name", "name"); has {
		v = strings.TrimSpace(v)
		if v == "" {
			c.jsonError(400, "职位名称不能为空")
			return
		}
		update["position_name"] = v
	}
	if v, has := c.getIntValue(body, "position_type"); has {
		update["position_type"] = int8(v)
	}
	if v, has := c.getIntValue(body, "status"); has {
		update["status"] = int8(v)
	}
	if v, has := c.getUintValue(body, "sort"); has {
		update["sort"] = v
	}
	if v, has := c.getStringValue(body, "remark"); has {
		update["remark"] = nullableString(v)
	}

	if len(update) == 0 {
		c.jsonError(400, "无更新字段")
		return
	}

	if _, err := c.positionQuery(tid).Filter("id", id).Update(update); err != nil {
		c.jsonError(500, "更新职位失败: "+err.Error())
		return
	}

	c.jsonOK(nil)
}

// DeletePosition 删除职位（软删除）。
// DELETE /backend/{erp|oa}/deletePosition/:id
func (c *BackendOrganizationController) DeletePosition() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}
	id, valid := c.pathUint64(":id")
	if !valid {
		c.jsonError(400, "无效ID")
		return
	}

	num, err := c.positionQuery(tid).Filter("id", id).
		Update(orm.Params{"delete_time": c.nowString(), "status": int8(0)})
	if err != nil {
		c.jsonError(500, "删除职位失败: "+err.Error())
		return
	}
	if num == 0 {
		c.jsonError(404, "职位不存在")
		return
	}

	c.jsonOK(nil)
}

// CheckPositionCodeUnique 检查职位编码唯一性。
// GET /backend/{erp|oa}/checkPositionCodeUnique?position_code=xx&exclude_id=1
func (c *BackendOrganizationController) CheckPositionCodeUnique() {
	tid, ok := c.tenantID()
	if !ok {
		return
	}
	code := strings.TrimSpace(c.GetString("position_code"))
	if code == "" {
		c.jsonError(400, "职位编码不能为空")
		return
	}
	excludeID, _ := c.GetUint64("exclude_id")

	qs := c.positionQuery(tid).Filter("position_code", code)
	if excludeID > 0 {
		qs = qs.Exclude("id", excludeID)
	}

	count, err := qs.Count()
	if err != nil {
		c.jsonError(500, "检查编码唯一性失败: "+err.Error())
		return
	}

	c.jsonOK(map[string]interface{}{"unique": count == 0, "message": uniqueMessage(count == 0, "编码")})
}