/**
 * 工单系统 API 服务
 * 模块: platform_tickets
 */
import apiClient, { PaginatedData, ApiClientError } from '@/lib/api-client';

// ==================== 类型定义 ====================

/**
 * 工单状态
 */
export enum TicketStatus {
  OPEN = 'OPEN',                  // 新建
  ASSIGNED = 'ASSIGNED',          // 已分配
  IN_PROGRESS = 'IN_PROGRESS',    // 处理中
  PENDING = 'PENDING',            // 挂起/等待
  RESOLVED = 'RESOLVED',          // 已解决
  CLOSED = 'CLOSED',              // 已关闭
  CANCELLED = 'CANCELLED',        // 已取消
}

/**
 * 工单优先级
 */
export enum TicketPriority {
  LOW = 'LOW',
  MEDIUM = 'MEDIUM',
  HIGH = 'HIGH',
  URGENT = 'URGENT',
}

/**
 * 工单来源
 */
export enum TicketSource {
  WEB = 'WEB',
  EMAIL = 'EMAIL',
  PHONE = 'PHONE',
  CHAT = 'CHAT',
  API = 'API',
}

/**
 * 评论类型
 */
export enum CommentType {
  COMMENT = 'COMMENT',
  NOTE = 'NOTE',
  STATUS_CHANGE = 'STATUS_CHANGE',
  ASSIGNMENT = 'ASSIGNMENT',
  RESOLUTION = 'RESOLUTION',
  AI_CONTEXT = 'AI_CONTEXT',
}

/**
 * 可见性范围
 */
export enum VisibilityScope {
  ALL = 'ALL',
  AGENT_ONLY = 'AGENT_ONLY',
  GROUP_ONLY = 'GROUP_ONLY',
}

/**
 * 分配策略
 */
export enum AssignmentStrategy {
  ROUND_ROBIN = 'ROUND_ROBIN',
  LOAD_BALANCE = 'LOAD_BALANCE',
  MANUAL = 'MANUAL',
  SKILL_BASED = 'SKILL_BASED',
}

// ==================== 接口类型 ====================

/**
 * 用户简要信息
 */
export interface UserBrief {
  id: string;
  displayName: string;
  email?: string;
}

/**
 * 工单分类
 */
export interface TicketCategory {
  id: string;
  code: string;
  name: string;
  description?: string;
  parentId?: string;
  parent?: TicketCategory;
  children?: TicketCategory[];
  icon?: string;
  color?: string;
  defaultPriority?: TicketPriority;
  defaultAssigneeGroupId?: string;
  slaId?: string;
  isActive: boolean;
  sortOrder: number;
  createdAt: string;
  updatedAt: string;
}

/**
 * 处理组
 */
export interface AssignmentGroup {
  id: string;
  code: string;
  name: string;
  description?: string;
  memberIds: string[];
  leaderId?: string;
  assignmentStrategy: AssignmentStrategy;
  isActive: boolean;
  createdAt: string;
  updatedAt: string;
}

/**
 * 附件
 */
export interface TicketAttachment {
  id: string;
  fileName: string;
  fileUrl: string;
  fileSize: number;
  mimeType: string;
  uploadedBy: string;
  createdAt: string;
}

/**
 * 评论
 */
export interface TicketComment {
  id: string;
  content: string;
  type: CommentType;
  isInternal: boolean;
  visibilityScope: VisibilityScope;
  author: UserBrief;
  attachments: TicketAttachment[];
  mentionedUsers: UserBrief[];
  createdAt: string;
}

/**
 * 活动日志
 */
export interface TicketActivity {
  id: string;
  type: string;
  content: Record<string, any>;
  operator: UserBrief | null;
  createdAt: string;
}

/**
 * 工单列表项
 */
export interface TicketListItem {
  id: string;
  ticketNo: string;
  title: string;
  status: TicketStatus;
  priority: TicketPriority;
  category: {
    id: string;
    name: string;
    code: string;
  };
  creator: UserBrief;
  assignee?: UserBrief;
  assigneeGroup?: {
    id: string;
    name: string;
  };
  tags: string[];
  source: TicketSource;
  createdAt: string;
  updatedAt: string;
  firstResponseAt?: string;
  resolvedAt?: string;
  dueAt?: string;
  slaBreached: boolean;
}

/**
 * 工单详情
 */
export interface TicketDetail extends TicketListItem {
  description: string;
  resolution?: string;
  attachments: TicketAttachment[];
  watchers: string[];
  satisfactionRating?: number;
  satisfactionComment?: string;
  closedAt?: string;
  language?: string;
  region: string;
}

// ==================== 请求参数类型 ====================

/**
 * 创建工单参数
 */
export interface CreateTicketParams {
  title: string;
  description: string;
  categoryId: string;
  priority?: TicketPriority;
  tags?: string[];
  source?: TicketSource;
  attachments?: {
    fileName: string;
    fileUrl: string;
    fileSize: number;
    mimeType: string;
  }[];
  language?: string;
}

/**
 * 更新工单参数
 */
export interface UpdateTicketParams {
  title?: string;
  description?: string;
  categoryId?: string;
  priority?: TicketPriority;
  tags?: string[];
}

/**
 * 更新工单状态参数
 */
export interface UpdateTicketStatusParams {
  status: TicketStatus;
  comment?: string;
  resolution?: string;
}

/**
 * 分配工单参数
 */
export interface AssignTicketParams {
  assigneeId?: string;
  assigneeGroupId?: string;
  comment?: string;
}

/**
 * 查询工单参数
 */
export interface QueryTicketParams {
  page?: number;
  limit?: number;
  status?: TicketStatus;
  priority?: TicketPriority;
  categoryId?: string;
  assigneeId?: string;
  creatorId?: string;
  keyword?: string;
  startDate?: string;
  endDate?: string;
  sortBy?: string;
  sortOrder?: 'asc' | 'desc';
}

/**
 * 添加评论参数
 */
export interface AddCommentParams {
  content: string;
  isInternal?: boolean;
  type?: CommentType;
  visibilityScope?: VisibilityScope;
  attachments?: {
    fileName: string;
    fileUrl: string;
    fileSize: number;
    mimeType: string;
  }[];
  mentionedUserIds?: string[];
}

/**
 * 满意度评价参数
 */
export interface SatisfactionParams {
  rating: number; // 1-5
  comment?: string;
}

/**
 * 创建分类参数
 */
export interface CreateCategoryParams {
  name: string;
  code: string;
  description?: string;
  parentId?: string;
  icon?: string;
  color?: string;
  defaultPriority?: TicketPriority;
  defaultAssigneeGroupId?: string;
}

/**
 * 创建处理组参数
 */
export interface CreateGroupParams {
  name: string;
  code: string;
  description?: string;
  memberIds?: string[];
  leaderId?: string;
  assignmentStrategy?: AssignmentStrategy;
}

// ==================== 统计类型 ====================

/**
 * 统计概览
 */
export interface StatsOverview {
  total: {
    all: number;
    open: number;
    inProgress: number;
    resolved: number;
    closed: number;
  };
  today: {
    created: number;
    resolved: number;
    closed: number;
  };
  sla: {
    onTime: number;
    breached: number;
    rate: number;
  };
  satisfaction: {
    average: number;
    count: number;
  };
}

/**
 * 分布统计
 */
export interface DistributionItem {
  status?: TicketStatus;
  category?: {
    id: string;
    name: string;
  };
  count: number;
  percentage: number;
}

/**
 * 趋势数据
 */
export interface TrendItem {
  date: string;
  created: number;
  resolved: number;
  closed: number;
}

/**
 * 工作量统计
 */
export interface WorkloadItem {
  assignee: UserBrief;
  total: number;
  open: number;
  inProgress: number;
  resolved: number;
  avgResolutionTime: number;
}

// ==================== API 函数 ====================

const BASE_URL = '/tickets';
const ADMIN_URL = '/tickets/admin';

// -------------------- 工单操作 --------------------

/**
 * 创建工单
 */
export async function createTicket(params: CreateTicketParams): Promise<TicketDetail> {
  return apiClient.post(BASE_URL, params);
}

/**
 * 获取工单列表
 */
export async function getTickets(params?: QueryTicketParams): Promise<PaginatedData<TicketListItem>> {
  return apiClient.get(BASE_URL, { params });
}

/**
 * 获取工单详情
 */
export async function getTicketById(id: string): Promise<TicketDetail> {
  return apiClient.get(`${BASE_URL}/${id}`);
}

/**
 * 更新工单
 */
export async function updateTicket(id: string, params: UpdateTicketParams): Promise<TicketDetail> {
  return apiClient.patch(`${BASE_URL}/${id}`, params);
}

/**
 * 删除工单（软删除）
 */
export async function deleteTicket(id: string): Promise<void> {
  return apiClient.delete(`${BASE_URL}/${id}`);
}

/**
 * 更新工单状态
 */
export async function updateTicketStatus(id: string, params: UpdateTicketStatusParams): Promise<TicketDetail> {
  return apiClient.patch(`${BASE_URL}/${id}/status`, params);
}

/**
 * 分配工单
 */
export async function assignTicket(id: string, params: AssignTicketParams): Promise<TicketDetail> {
  return apiClient.post(`${BASE_URL}/${id}/assign`, params);
}

// -------------------- 评论操作 --------------------

/**
 * 获取评论列表
 */
export async function getComments(ticketId: string, params?: { page?: number; limit?: number }): Promise<PaginatedData<TicketComment>> {
  return apiClient.get(`${BASE_URL}/${ticketId}/comments`, { params });
}

/**
 * 添加评论
 */
export async function addComment(ticketId: string, params: AddCommentParams): Promise<TicketComment> {
  return apiClient.post(`${BASE_URL}/${ticketId}/comments`, params);
}

/**
 * 删除评论
 */
export async function deleteComment(ticketId: string, commentId: string): Promise<void> {
  return apiClient.delete(`${BASE_URL}/${ticketId}/comments/${commentId}`);
}

// -------------------- 满意度 --------------------

/**
 * 提交满意度评价
 */
export async function submitSatisfaction(ticketId: string, params: SatisfactionParams): Promise<TicketDetail> {
  return apiClient.post(`${BASE_URL}/${ticketId}/satisfaction`, params);
}

// -------------------- 关注 --------------------

/**
 * 关注工单
 */
export async function watchTicket(ticketId: string): Promise<void> {
  return apiClient.post(`${BASE_URL}/${ticketId}/watch`);
}

/**
 * 取消关注
 */
export async function unwatchTicket(ticketId: string): Promise<void> {
  return apiClient.delete(`${BASE_URL}/${ticketId}/watch`);
}

// -------------------- 活动日志 --------------------

/**
 * 获取活动日志
 */
export async function getActivities(ticketId: string, params?: { page?: number; limit?: number }): Promise<PaginatedData<TicketActivity>> {
  return apiClient.get(`${BASE_URL}/${ticketId}/activities`, { params });
}

// -------------------- 分类管理 --------------------

/**
 * 获取分类列表
 */
export async function getCategories(): Promise<TicketCategory[]> {
  return apiClient.get(`${ADMIN_URL}/categories`);
}

/**
 * 获取分类树
 */
export async function getCategoryTree(): Promise<TicketCategory[]> {
  return apiClient.get(`${ADMIN_URL}/categories/tree`);
}

/**
 * 获取分类详情
 */
export async function getCategoryById(id: string): Promise<TicketCategory> {
  return apiClient.get(`${ADMIN_URL}/categories/${id}`);
}

/**
 * 创建分类
 */
export async function createCategory(params: CreateCategoryParams): Promise<TicketCategory> {
  return apiClient.post(`${ADMIN_URL}/categories`, params);
}

/**
 * 更新分类
 */
export async function updateCategory(id: string, params: Partial<CreateCategoryParams>): Promise<TicketCategory> {
  return apiClient.patch(`${ADMIN_URL}/categories/${id}`, params);
}

/**
 * 删除分类
 */
export async function deleteCategory(id: string): Promise<void> {
  return apiClient.delete(`${ADMIN_URL}/categories/${id}`);
}

// -------------------- 处理组管理 --------------------

/**
 * 获取处理组列表
 */
export async function getGroups(): Promise<AssignmentGroup[]> {
  return apiClient.get(`${ADMIN_URL}/groups`);
}

/**
 * 获取处理组详情
 */
export async function getGroupById(id: string): Promise<AssignmentGroup> {
  return apiClient.get(`${ADMIN_URL}/groups/${id}`);
}

/**
 * 创建处理组
 */
export async function createGroup(params: CreateGroupParams): Promise<AssignmentGroup> {
  return apiClient.post(`${ADMIN_URL}/groups`, params);
}

/**
 * 更新处理组
 */
export async function updateGroup(id: string, params: Partial<CreateGroupParams>): Promise<AssignmentGroup> {
  return apiClient.patch(`${ADMIN_URL}/groups/${id}`, params);
}

/**
 * 删除处理组
 */
export async function deleteGroup(id: string): Promise<void> {
  return apiClient.delete(`${ADMIN_URL}/groups/${id}`);
}

/**
 * 更新处理组成员
 */
export async function updateGroupMembers(id: string, memberIds: string[]): Promise<AssignmentGroup> {
  return apiClient.put(`${ADMIN_URL}/groups/${id}/members`, { memberIds });
}

// -------------------- 统计 --------------------

/**
 * 获取统计概览
 */
export async function getStatsOverview(): Promise<StatsOverview> {
  return apiClient.get(`${ADMIN_URL}/stats/overview`);
}

/**
 * 获取状态分布
 */
export async function getStatusDistribution(): Promise<DistributionItem[]> {
  return apiClient.get(`${ADMIN_URL}/stats/status-distribution`);
}

/**
 * 获取分类分布
 */
export async function getCategoryDistribution(): Promise<DistributionItem[]> {
  return apiClient.get(`${ADMIN_URL}/stats/category-distribution`);
}

/**
 * 获取趋势数据
 */
export async function getTrends(days: number = 7): Promise<TrendItem[]> {
  return apiClient.get(`${ADMIN_URL}/stats/trends`, { params: { days } });
}

/**
 * 获取工作量统计
 */
export async function getWorkload(): Promise<WorkloadItem[]> {
  return apiClient.get(`${ADMIN_URL}/stats/workload`);
}

// ==================== 辅助函数 ====================

/**
 * 获取状态标签
 */
export function getStatusLabel(status: TicketStatus, t?: any): string {
  const labels: Record<TicketStatus, string> = {
    [TicketStatus.OPEN]: t?.tickets?.status?.open || '新建',
    [TicketStatus.ASSIGNED]: t?.tickets?.status?.assigned || '已分配',
    [TicketStatus.IN_PROGRESS]: t?.tickets?.status?.inProgress || '处理中',
    [TicketStatus.PENDING]: t?.tickets?.status?.pending || '挂起',
    [TicketStatus.RESOLVED]: t?.tickets?.status?.resolved || '已解决',
    [TicketStatus.CLOSED]: t?.tickets?.status?.closed || '已关闭',
    [TicketStatus.CANCELLED]: t?.tickets?.status?.cancelled || '已取消',
  };
  return labels[status] || status;
}

/**
 * 获取状态颜色
 */
export function getStatusColor(status: TicketStatus): { bg: string; text: string; border: string } {
  const colors: Record<TicketStatus, { bg: string; text: string; border: string }> = {
    [TicketStatus.OPEN]: { bg: 'bg-blue-50', text: 'text-blue-600', border: 'border-blue-200' },
    [TicketStatus.ASSIGNED]: { bg: 'bg-indigo-50', text: 'text-indigo-600', border: 'border-indigo-200' },
    [TicketStatus.IN_PROGRESS]: { bg: 'bg-yellow-50', text: 'text-yellow-600', border: 'border-yellow-200' },
    [TicketStatus.PENDING]: { bg: 'bg-orange-50', text: 'text-orange-600', border: 'border-orange-200' },
    [TicketStatus.RESOLVED]: { bg: 'bg-green-50', text: 'text-green-600', border: 'border-green-200' },
    [TicketStatus.CLOSED]: { bg: 'bg-gray-50', text: 'text-gray-600', border: 'border-gray-200' },
    [TicketStatus.CANCELLED]: { bg: 'bg-red-50', text: 'text-red-600', border: 'border-red-200' },
  };
  return colors[status] || { bg: 'bg-gray-50', text: 'text-gray-600', border: 'border-gray-200' };
}

/**
 * 获取优先级标签
 */
export function getPriorityLabel(priority: TicketPriority, t?: any): string {
  const labels: Record<TicketPriority, string> = {
    [TicketPriority.LOW]: t?.tickets?.priority?.low || '低',
    [TicketPriority.MEDIUM]: t?.tickets?.priority?.medium || '中',
    [TicketPriority.HIGH]: t?.tickets?.priority?.high || '高',
    [TicketPriority.URGENT]: t?.tickets?.priority?.urgent || '紧急',
  };
  return labels[priority] || priority;
}

/**
 * 获取优先级颜色
 */
export function getPriorityColor(priority: TicketPriority): { bg: string; text: string; border: string } {
  const colors: Record<TicketPriority, { bg: string; text: string; border: string }> = {
    [TicketPriority.LOW]: { bg: 'bg-gray-50', text: 'text-gray-600', border: 'border-gray-200' },
    [TicketPriority.MEDIUM]: { bg: 'bg-blue-50', text: 'text-blue-600', border: 'border-blue-200' },
    [TicketPriority.HIGH]: { bg: 'bg-orange-50', text: 'text-orange-600', border: 'border-orange-200' },
    [TicketPriority.URGENT]: { bg: 'bg-red-50', text: 'text-red-600', border: 'border-red-200' },
  };
  return colors[priority] || { bg: 'bg-gray-50', text: 'text-gray-600', border: 'border-gray-200' };
}

/**
 * 获取来源标签
 */
export function getSourceLabel(source: TicketSource, t?: any): string {
  const labels: Record<TicketSource, string> = {
    [TicketSource.WEB]: t?.tickets?.source?.web || '网页',
    [TicketSource.EMAIL]: t?.tickets?.source?.email || '邮件',
    [TicketSource.PHONE]: t?.tickets?.source?.phone || '电话',
    [TicketSource.CHAT]: t?.tickets?.source?.chat || '在线聊天',
    [TicketSource.API]: t?.tickets?.source?.api || 'API',
  };
  return labels[source] || source;
}

// 导出错误类
export { ApiClientError };