import type { AffinityRule, AffinityLevel } from "./types"
import { mockResponse, type PaginatedResponse, type PaginationParams } from "./client"

// 模拟好感度规则数据
const mockAffinityRules: AffinityRule[] = [
  {
    id: "AFR001",
    name: "每日登录",
    description: "用户每日登录系统可获得好感度",
    points: 10,
    type: "日常活动",
    status: "已启用",
  },
  {
    id: "AFR002",
    name: "赠送礼物",
    description: "用户赠送礼物可获得好感度",
    points: 20,
    type: "互动活动",
    status: "已启用",
  },
  {
    id: "AFR003",
    name: "完成任务",
    description: "用户完成指定任务可获得好感度",
    points: 15,
    type: "任务活动",
    status: "已启用",
  },
  {
    id: "AFR004",
    name: "参与活动",
    description: "用户参与系统活动可获得好感度",
    points: 30,
    type: "特殊活动",
    status: "已启用",
  },
  {
    id: "AFR005",
    name: "购买道具",
    description: "用户购买道具可获得好感度",
    points: 25,
    type: "消费活动",
    status: "未启用",
  },
]

// 模拟好感度等级数据
const mockAffinityLevels: AffinityLevel[] = [
  {
    id: "AFL001",
    level: 1,
    name: "初识",
    pointsRequired: 0,
    rewards: ["基础表情包", "基础头像框"],
    description: "刚刚认识洛天依，开始了解她的世界。",
  },
  {
    id: "AFL002",
    level: 2,
    name: "相识",
    pointsRequired: 100,
    rewards: ["语音问候", "特殊表情包"],
    description: "与洛天依有了初步的交流，开始建立友谊。",
  },
  {
    id: "AFL003",
    level: 3,
    name: "熟悉",
    pointsRequired: 300,
    rewards: ["专属头像框", "房间装饰道具"],
    description: "与洛天依建立了稳定的友谊，互相了解更多。",
  },
  {
    id: "AFL004",
    level: 4,
    name: "亲密",
    pointsRequired: 600,
    rewards: ["专属服装", "专属互动动画"],
    description: "与洛天依建立了深厚的友谊，成为了亲密的朋友。",
  },
  {
    id: "AFL005",
    level: 5,
    name: "挚友",
    pointsRequired: 1000,
    rewards: ["限定服装", "专属歌曲", "特殊互动场景"],
    description: "与洛天依建立了最亲密的关系，成为了无可替代的挚友。",
  },
]

// 获取好感度规则列表
export const getAffinityRules = async (params?: PaginationParams): Promise<PaginatedResponse<AffinityRule>> => {
  let filteredRules = [...mockAffinityRules]

  // 搜索过滤
  if (params?.search) {
    const search = params.search.toLowerCase()
    filteredRules = filteredRules.filter(
      (rule) =>
        rule.name.toLowerCase().includes(search) ||
        rule.description.toLowerCase().includes(search) ||
        rule.type.toLowerCase().includes(search),
    )
  }

  // 排序
  if (params?.sortBy) {
    filteredRules.sort((a: any, b: any) => {
      const aValue = a[params.sortBy!]
      const bValue = b[params.sortBy!]

      if (typeof aValue === "string" && typeof bValue === "string") {
        return params.sortOrder === "desc" ? bValue.localeCompare(aValue) : aValue.localeCompare(bValue)
      }

      return params.sortOrder === "desc" ? bValue - aValue : aValue - bValue
    })
  }

  // 分页
  const page = params?.page || 1
  const pageSize = params?.pageSize || 10
  const startIndex = (page - 1) * pageSize
  const paginatedRules = filteredRules.slice(startIndex, startIndex + pageSize)

  return mockResponse({
    items: paginatedRules,
    total: filteredRules.length,
    page,
    pageSize,
    totalPages: Math.ceil(filteredRules.length / pageSize),
  })
}

// 获取单个好感度规则
export const getAffinityRule = async (id: string): Promise<AffinityRule> => {
  const rule = mockAffinityRules.find((rule) => rule.id === id)

  if (!rule) {
    return mockResponse({} as AffinityRule, "好感度规则不存在")
  }

  return mockResponse(rule)
}

// 创建好感度规则
export const createAffinityRule = async (ruleData: Partial<AffinityRule>): Promise<AffinityRule> => {
  // 生成新的好感度规则ID
  const ruleId = "AFR" + String(mockAffinityRules.length + 1).padStart(3, "0")

  const newRule: AffinityRule = {
    id: ruleId,
    name: ruleData.name || "",
    description: ruleData.description || "",
    points: ruleData.points || 0,
    type: ruleData.type || "",
    status: ruleData.status || "未启用",
  }

  mockAffinityRules.push(newRule)

  return mockResponse(newRule)
}

// 更新好感度规则
export const updateAffinityRule = async (id: string, ruleData: Partial<AffinityRule>): Promise<AffinityRule> => {
  const ruleIndex = mockAffinityRules.findIndex((rule) => rule.id === id)

  if (ruleIndex === -1) {
    return mockResponse({} as AffinityRule, "好感度规则不存在")
  }

  const updatedRule = {
    ...mockAffinityRules[ruleIndex],
    ...ruleData,
  }

  mockAffinityRules[ruleIndex] = updatedRule

  return mockResponse(updatedRule)
}

// 删除好感度规则
export const deleteAffinityRule = async (id: string): Promise<boolean> => {
  const ruleIndex = mockAffinityRules.findIndex((rule) => rule.id === id)

  if (ruleIndex === -1) {
    return mockResponse(false, "好感度规则不存在")
  }

  mockAffinityRules.splice(ruleIndex, 1)

  return mockResponse(true)
}

// 获取好感度等级列表
export const getAffinityLevels = async (params?: PaginationParams): Promise<PaginatedResponse<AffinityLevel>> => {
  let filteredLevels = [...mockAffinityLevels]

  // 搜索过滤
  if (params?.search) {
    const search = params.search.toLowerCase()
    filteredLevels = filteredLevels.filter(
      (level) => level.name.toLowerCase().includes(search) || level.description.toLowerCase().includes(search),
    )
  }

  // 排序
  if (params?.sortBy) {
    filteredLevels.sort((a: any, b: any) => {
      const aValue = a[params.sortBy!]
      const bValue = b[params.sortBy!]

      if (typeof aValue === "string" && typeof bValue === "string") {
        return params.sortOrder === "desc" ? bValue.localeCompare(aValue) : aValue.localeCompare(bValue)
      }

      return params.sortOrder === "desc" ? bValue - aValue : aValue - bValue
    })
  } else {
    // 默认按等级排序
    filteredLevels.sort((a, b) => a.level - b.level)
  }

  // 分页
  const page = params?.page || 1
  const pageSize = params?.pageSize || 10
  const startIndex = (page - 1) * pageSize
  const paginatedLevels = filteredLevels.slice(startIndex, startIndex + pageSize)

  return mockResponse({
    items: paginatedLevels,
    total: filteredLevels.length,
    page,
    pageSize,
    totalPages: Math.ceil(filteredLevels.length / pageSize),
  })
}

// 获取单个好感度等级
export const getAffinityLevel = async (id: string): Promise<AffinityLevel> => {
  const level = mockAffinityLevels.find((level) => level.id === id)

  if (!level) {
    return mockResponse({} as AffinityLevel, "好感度等级不存在")
  }

  return mockResponse(level)
}

// 创建好感度等级
export const createAffinityLevel = async (levelData: Partial<AffinityLevel>): Promise<AffinityLevel> => {
  // 生成新的好感度等级ID
  const levelId = "AFL" + String(mockAffinityLevels.length + 1).padStart(3, "0")

  const newLevel: AffinityLevel = {
    id: levelId,
    level: levelData.level || mockAffinityLevels.length + 1,
    name: levelData.name || "",
    pointsRequired: levelData.pointsRequired || 0,
    rewards: levelData.rewards || [],
    description: levelData.description || "",
  }

  mockAffinityLevels.push(newLevel)

  // 按等级排序
  mockAffinityLevels.sort((a, b) => a.level - b.level)

  return mockResponse(newLevel)
}

// 更新好感度等级
export const updateAffinityLevel = async (id: string, levelData: Partial<AffinityLevel>): Promise<AffinityLevel> => {
  const levelIndex = mockAffinityLevels.findIndex((level) => level.id === id)

  if (levelIndex === -1) {
    return mockResponse({} as AffinityLevel, "好感度等级不存在")
  }

  const updatedLevel = {
    ...mockAffinityLevels[levelIndex],
    ...levelData,
  }

  mockAffinityLevels[levelIndex] = updatedLevel

  // 按等级排序
  mockAffinityLevels.sort((a, b) => a.level - b.level)

  return mockResponse(updatedLevel)
}

// 删除好感度等级
export const deleteAffinityLevel = async (id: string): Promise<boolean> => {
  const levelIndex = mockAffinityLevels.findIndex((level) => level.id === id)

  if (levelIndex === -1) {
    return mockResponse(false, "好感度等级不存在")
  }

  mockAffinityLevels.splice(levelIndex, 1)

  return mockResponse(true)
}