package controllers

import (
	"encoding/json"
	"io"
	"strconv"
	"strings"
	"time"

	"server/models"

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

// PlatformTenantController 平台端租户管理
type PlatformTenantController struct {
	beego.Controller
}

type tenantDTO struct {
	ID            uint64     `json:"id"`
	TenantCode    string     `json:"tenant_code"`
	TenantName    string     `json:"tenant_name"`
	ContactPerson string     `json:"contact_person"`
	ContactPhone  string     `json:"contact_phone"`
	ContactEmail  string     `json:"contact_email"`
	Address       string     `json:"address"`
	Worktime      string     `json:"worktime"`
	Status        int8       `json:"status"`
	Remark        string     `json:"remark"`
	CreateTime    *time.Time `json:"create_time,omitempty"`
	UpdateTime    *time.Time `json:"update_time,omitempty"`
	DeleteTime    *time.Time `json:"delete_time,omitempty"`
}

func toTenantDTO(t models.Tenant) tenantDTO {
	ct := t.CreateTime
	ut := t.UpdateTime
	return tenantDTO{
		ID:            t.ID,
		TenantCode:    t.TenantCode,
		TenantName:    t.TenantName,
		ContactPerson: t.ContactPerson,
		ContactPhone:  t.ContactPhone,
		ContactEmail:  t.ContactEmail,
		Address:       t.Address,
		Worktime:      t.Worktime,
		Status:        t.Status,
		Remark:        t.Remark,
		CreateTime:    &ct,
		UpdateTime:    &ut,
		DeleteTime:    t.DeleteTime,
	}
}

// GetTenant 获取租户列表
// GET /platform/tenant/getTenant?page=1&pageSize=10&tenant_name=...&tenant_code=...&contact_person=...&contact_phone=...
func (c *PlatformTenantController) GetTenant() {
	page, _ := c.GetInt("page", 1)
	pageSize, _ := c.GetInt("pageSize", 10)
	if page < 1 {
		page = 1
	}
	if pageSize < 1 {
		pageSize = 10
	}

	tenantName := strings.TrimSpace(c.GetString("tenant_name"))
	tenantCode := strings.TrimSpace(c.GetString("tenant_code"))
	contactPerson := strings.TrimSpace(c.GetString("contact_person"))
	contactPhone := strings.TrimSpace(c.GetString("contact_phone"))

	qs := models.Orm.QueryTable(new(models.Tenant))
	if tenantName != "" {
		qs = qs.Filter("tenant_name__icontains", tenantName)
	}
	if tenantCode != "" {
		qs = qs.Filter("tenant_code__icontains", tenantCode)
	}
	if contactPerson != "" {
		qs = qs.Filter("contact_person__icontains", contactPerson)
	}
	if contactPhone != "" {
		qs = qs.Filter("contact_phone__icontains", contactPhone)
	}

	total, err := qs.Count()
	if err != nil {
		c.Data["json"] = map[string]interface{}{"code": 500, "msg": "获取租户失败: " + err.Error()}
		_ = c.ServeJSON()
		return
	}

	var rows []models.Tenant
	_, err = qs.OrderBy("-id").Limit(pageSize, (page-1)*pageSize).All(&rows)
	if err != nil {
		c.Data["json"] = map[string]interface{}{"code": 500, "msg": "获取租户失败: " + err.Error()}
		_ = c.ServeJSON()
		return
	}

	list := make([]tenantDTO, 0, len(rows))
	for _, t := range rows {
		list = append(list, toTenantDTO(t))
	}

	c.Data["json"] = map[string]interface{}{
		"code": 200,
		"msg":  "success",
		"data": map[string]interface{}{
			"list":  list,
			"total": total,
		},
	}
	_ = c.ServeJSON()
}

// GetTenantDetail 获取租户详情
// GET /platform/tenant/getTenantDetail/:id
func (c *PlatformTenantController) GetTenantDetail() {
	id, err := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
	if err != nil || id == 0 {
		c.Data["json"] = map[string]interface{}{"code": 400, "msg": "无效ID"}
		_ = c.ServeJSON()
		return
	}

	var t models.Tenant
	err = models.Orm.QueryTable(new(models.Tenant)).Filter("id", id).One(&t)
	if err != nil {
		c.Data["json"] = map[string]interface{}{"code": 404, "msg": "租户不存在"}
		_ = c.ServeJSON()
		return
	}

	c.Data["json"] = map[string]interface{}{
		"code": 200,
		"msg":  "success",
		"data": toTenantDTO(t),
	}
	_ = c.ServeJSON()
}

type tenantPayload struct {
	TenantCode    string `json:"tenant_code"`
	TenantName    string `json:"tenant_name"`
	ContactPerson string `json:"contact_person"`
	ContactPhone  string `json:"contact_phone"`
	ContactEmail  string `json:"contact_email"`
	Address       string `json:"address"`
	Worktime      string `json:"worktime"`
	Status        *int8  `json:"status"`
	Remark        string `json:"remark"`
}

func (c *PlatformTenantController) parseTenantPayload() (tenantPayload, error) {
	// 优先从表单读取（createTenant 使用 multipart/form-data）
	p := tenantPayload{
		TenantCode:    strings.TrimSpace(c.GetString("tenant_code")),
		TenantName:    strings.TrimSpace(c.GetString("tenant_name")),
		ContactPerson: strings.TrimSpace(c.GetString("contact_person")),
		ContactPhone:  strings.TrimSpace(c.GetString("contact_phone")),
		ContactEmail:  strings.TrimSpace(c.GetString("contact_email")),
		Address:       strings.TrimSpace(c.GetString("address")),
		Worktime:      strings.TrimSpace(c.GetString("worktime")),
		Remark:        strings.TrimSpace(c.GetString("remark")),
	}
	if s := strings.TrimSpace(c.GetString("status")); s != "" {
		if v, err := strconv.ParseInt(s, 10, 8); err == nil {
			tmp := int8(v)
			p.Status = &tmp
		}
	}

	// 如果关键字段为空，尝试从 JSON body 解析（editTenant 默认 JSON）
	if p.TenantName == "" && p.TenantCode == "" {
		raw, _ := io.ReadAll(c.Ctx.Request.Body)
		if len(raw) > 0 {
			_ = json.Unmarshal(raw, &p)
		}
	}
	return p, nil
}

// CreateTenant 创建租户
// POST /platform/tenant/createTenant
func (c *PlatformTenantController) CreateTenant() {
	p, _ := c.parseTenantPayload()
	if strings.TrimSpace(p.TenantName) == "" {
		c.Data["json"] = map[string]interface{}{"code": 400, "msg": "租户名称不能为空"}
		_ = c.ServeJSON()
		return
	}
	if strings.TrimSpace(p.TenantCode) == "" {
		c.Data["json"] = map[string]interface{}{"code": 400, "msg": "租户编码不能为空"}
		_ = c.ServeJSON()
		return
	}

	// 校验编码唯一
	cnt, err := models.Orm.QueryTable(new(models.Tenant)).Filter("tenant_code", p.TenantCode).Count()
	if err != nil {
		c.Data["json"] = map[string]interface{}{"code": 500, "msg": "创建失败: " + err.Error()}
		_ = c.ServeJSON()
		return
	}
	if cnt > 0 {
		c.Data["json"] = map[string]interface{}{"code": 400, "msg": "租户编码已存在"}
		_ = c.ServeJSON()
		return
	}

	status := int8(1)
	if p.Status != nil {
		status = *p.Status
	}

	t := models.Tenant{
		TenantCode:    p.TenantCode,
		TenantName:    p.TenantName,
		ContactPerson: p.ContactPerson,
		ContactPhone:  p.ContactPhone,
		ContactEmail:  p.ContactEmail,
		Address:       p.Address,
		Worktime:      p.Worktime,
		Status:        status,
		Remark:        p.Remark,
	}

	id, err := models.Orm.Insert(&t)
	if err != nil {
		c.Data["json"] = map[string]interface{}{"code": 500, "msg": "创建失败: " + err.Error()}
		_ = c.ServeJSON()
		return
	}

	c.Data["json"] = map[string]interface{}{
		"code": 200,
		"msg":  "success",
		"data": map[string]interface{}{"id": id},
	}
	_ = c.ServeJSON()
}

// EditTenant 编辑租户
// POST /platform/tenant/editTenant/:id
func (c *PlatformTenantController) EditTenant() {
	id, err := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
	if err != nil || id == 0 {
		c.Data["json"] = map[string]interface{}{"code": 400, "msg": "无效ID"}
		_ = c.ServeJSON()
		return
	}

	p, _ := c.parseTenantPayload()
	if strings.TrimSpace(p.TenantName) == "" {
		c.Data["json"] = map[string]interface{}{"code": 400, "msg": "租户名称不能为空"}
		_ = c.ServeJSON()
		return
	}

	update := map[string]interface{}{
		"tenant_name":    p.TenantName,
		"contact_person": p.ContactPerson,
		"contact_phone":  p.ContactPhone,
		"contact_email":  p.ContactEmail,
		"address":        p.Address,
		"worktime":       p.Worktime,
		"remark":         p.Remark,
	}
	if p.Status != nil {
		update["status"] = *p.Status
	}

	_, err = models.Orm.QueryTable(new(models.Tenant)).Filter("id", id).Update(update)
	if err != nil {
		c.Data["json"] = map[string]interface{}{"code": 500, "msg": "更新失败: " + err.Error()}
		_ = c.ServeJSON()
		return
	}

	c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success"}
	_ = c.ServeJSON()
}

// DeleteTenant 删除租户
// DELETE /platform/tenant/deleteTenant/:id
func (c *PlatformTenantController) DeleteTenant() {
	id, err := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
	if err != nil || id == 0 {
		c.Data["json"] = map[string]interface{}{"code": 400, "msg": "无效ID"}
		_ = c.ServeJSON()
		return
	}

	_, err = models.Orm.QueryTable(new(models.Tenant)).Filter("id", id).Delete()
	if err != nil {
		c.Data["json"] = map[string]interface{}{"code": 500, "msg": "删除失败: " + err.Error()}
		_ = c.ServeJSON()
		return
	}

	c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success"}
	_ = c.ServeJSON()
}

// FindTenantCode 校验租户编码是否重复
// GET /platform/tenant/findTenantCode?tenant_code=xxxxxx
// 返回 code=200 表示可用；非200表示重复/不可用（前端会自动重新生成）
func (c *PlatformTenantController) FindTenantCode() {
	code := strings.TrimSpace(c.GetString("tenant_code"))
	if code == "" {
		c.Data["json"] = map[string]interface{}{"code": 400, "msg": "tenant_code 不能为空"}
		_ = c.ServeJSON()
		return
	}

	cnt, err := models.Orm.QueryTable(new(models.Tenant)).Filter("tenant_code", code).Count()
	if err != nil {
		c.Data["json"] = map[string]interface{}{"code": 500, "msg": "校验失败: " + err.Error()}
		_ = c.ServeJSON()
		return
	}
	if cnt > 0 {
		c.Data["json"] = map[string]interface{}{"code": 409, "msg": "租户编码已存在"}
		_ = c.ServeJSON()
		return
	}

	c.Data["json"] = map[string]interface{}{"code": 200, "msg": "ok"}
	_ = c.ServeJSON()
}