export const API_BASE = 'http://localhost:8081/api'

// 通用请求头配置
export const getAuthHeaders = () => {
  const token = localStorage.getItem('token')
  return {
    'Content-Type': 'application/json',
    ...(token ? { Authorization: `Bearer ${token}` } : {})
  }
}

// 认证相关类型
export interface User {
  id: number
  username: string
  email: string
  role: string
  isActive: number
  createdAt: string
  updatedAt: string
}

export interface LoginRequest {
  username: string
  password: string
}

export interface LoginResponse {
  token: string
  user: User
  expire: number
}

// 角色相关类型
export interface Role {
  id: number
  name: string
  description: string
  createdAt: string
  updatedAt: string
}

// 作品相关类型
export interface Work {
  id: string
  title: string
  category: string
  year: string
  heroImg: string
  desc: string
  techStack: { category: string; items: string[] }[]
  gallery: string[]
  links: { live: string }
  next: string
}

// 文章相关类型
export interface Post {
  id: string
  title: string
  category: string
  date: string
  excerpt?: string
  content?: string
  isPublished?: number
}

export interface PostHistory {
  id: number
  postId: string
  version: number
  title: string
  category: string
  excerpt?: string
  content: string
  isPublished: number
  modifiedBy: number
  modifiedAt: string
  createdAt: string
}

// 代码片段相关类型
export interface Snippet {
  id: string
  title: string
  code: string
  type: string
  description?: string
  viewCount?: number
}

// 系统配置相关类型
export interface Setting {
  id: number
  keyName: string
  value: string
  description: string
  createdAt: string
  updatedAt: string
}

// 操作日志相关类型
export interface OperationLog {
  id: number
  userId: number
  username: string
  ip: string
  path: string
  method: string
  params: string
  status: number
  duration: number
  createdAt: string
}

// 分页响应类型
export interface PaginationResponse<T> {
  list: T[]
  total: number
  page: number
  size: number
}

// 登录API
export const login = async (credentials: LoginRequest): Promise<LoginResponse> => {
  try {
    const response = await fetch(`${API_BASE}/admin/login`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(credentials),
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '登录失败')
    }
    return await response.json()
  } catch (error) {
    console.error('Login error:', error)
    throw error
  }
}

// 用户管理API
export const getUsers = async (): Promise<User[]> => {
  try {
    const response = await fetch(`${API_BASE}/admin/users`, {
      headers: getAuthHeaders()
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '获取用户列表失败')
    }
    return await response.json()
  } catch (error) {
    console.error('Get users error:', error)
    throw error
  }
}

export const fetchUser = async (id: number): Promise<User> => {
  try {
    const response = await fetch(`${API_BASE}/admin/users/${id}`, {
      headers: getAuthHeaders()
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '获取用户详情失败')
    }
    return await response.json()
  } catch (error) {
    console.error(`Error fetching user ${id}:`, error)
    throw error
  }
}

export const createUser = async (userData: Omit<User, 'id' | 'createdAt' | 'updatedAt'>): Promise<void> => {
  try {
    const response = await fetch(`${API_BASE}/admin/users`, {
      method: 'POST',
      headers: getAuthHeaders(),
      body: JSON.stringify(userData)
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '创建用户失败')
    }
  } catch (error) {
    console.error('Create user error:', error)
    throw error
  }
}

export const updateUser = async (id: number, userData: Omit<User, 'id' | 'createdAt' | 'updatedAt'>): Promise<void> => {
  try {
    const response = await fetch(`${API_BASE}/admin/users/${id}`, {
      method: 'PUT',
      headers: getAuthHeaders(),
      body: JSON.stringify(userData)
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '更新用户失败')
    }
  } catch (error) {
    console.error('Update user error:', error)
    throw error
  }
}

export const deleteUser = async (id: number): Promise<void> => {
  try {
    const response = await fetch(`${API_BASE}/admin/users/${id}`, {
      method: 'DELETE',
      headers: getAuthHeaders()
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '删除用户失败')
    }
  } catch (error) {
    console.error('Delete user error:', error)
    throw error
  }
}

// 角色管理API
export const getRoles = async (): Promise<Role[]> => {
  try {
    const response = await fetch(`${API_BASE}/admin/roles`, {
      headers: getAuthHeaders()
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '获取角色列表失败')
    }
    return await response.json()
  } catch (error) {
    console.error('Get roles error:', error)
    throw error
  }
}

export const createRole = async (roleData: Omit<Role, 'id' | 'createdAt' | 'updatedAt'>): Promise<void> => {
  try {
    const response = await fetch(`${API_BASE}/admin/roles`, {
      method: 'POST',
      headers: getAuthHeaders(),
      body: JSON.stringify(roleData)
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '创建角色失败')
    }
  } catch (error) {
    console.error('Create role error:', error)
    throw error
  }
}

export const updateRole = async (id: number, roleData: Omit<Role, 'id' | 'createdAt' | 'updatedAt'>): Promise<void> => {
  try {
    const response = await fetch(`${API_BASE}/admin/roles/${id}`, {
      method: 'PUT',
      headers: getAuthHeaders(),
      body: JSON.stringify(roleData)
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '更新角色失败')
    }
  } catch (error) {
    console.error('Update role error:', error)
    throw error
  }
}

export const deleteRole = async (id: number): Promise<void> => {
  try {
    const response = await fetch(`${API_BASE}/admin/roles/${id}`, {
      method: 'DELETE',
      headers: getAuthHeaders()
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '删除角色失败')
    }
  } catch (error) {
    console.error('Delete role error:', error)
    throw error
  }
}

export const fetchRole = async (id: number): Promise<Role> => {
  try {
    const response = await fetch(`${API_BASE}/admin/roles/${id}`, {
      headers: getAuthHeaders()
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '获取角色详情失败')
    }
    return await response.json()
  } catch (error) {
    console.error(`Error fetching role ${id}:`, error)
    throw error
  }
}

// 作品管理API
export const getAdminWorks = async (): Promise<Work[]> => {
  try {
    const response = await fetch(`${API_BASE}/admin/works`, {
      headers: getAuthHeaders()
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '获取作品列表失败')
    }
    return await response.json()
  } catch (error) {
    console.error('Get admin works error:', error)
    throw error
  }
}

export const fetchWorks = async (): Promise<Work[]> => {
  try {
    const response = await fetch(`${API_BASE}/works`)
    if (!response.ok) throw new Error('Failed to fetch works')
    return await response.json()
  } catch (error) {
    console.error('Error fetching works:', error)
    return []
  }
}

export const fetchWork = async (id: string): Promise<Work> => {
  try {
    const response = await fetch(`${API_BASE}/works/${id}`)
    if (!response.ok) throw new Error('Failed to fetch work')
    return await response.json()
  } catch (error) {
    console.error(`Error fetching work ${id}:`, error)
    return {
      id: 'default',
      title: '默认作品',
      category: '默认分类',
      year: '2024',
      heroImg: '',
      desc: '',
      techStack: [],
      gallery: [],
      links: { live: '#' },
      next: ''
    }
  }
}

export const createWork = async (workData: Omit<Work, 'id' | 'next'>): Promise<void> => {
  try {
    const response = await fetch(`${API_BASE}/admin/works`, {
      method: 'POST',
      headers: getAuthHeaders(),
      body: JSON.stringify(workData)
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '创建作品失败')
    }
  } catch (error) {
    console.error('Create work error:', error)
    throw error
  }
}

export const updateWork = async (id: string, workData: Omit<Work, 'id' | 'next'>): Promise<void> => {
  try {
    const response = await fetch(`${API_BASE}/admin/works/${id}`, {
      method: 'PUT',
      headers: getAuthHeaders(),
      body: JSON.stringify(workData)
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '更新作品失败')
    }
  } catch (error) {
    console.error('Update work error:', error)
    throw error
  }
}

export const deleteWork = async (id: string): Promise<void> => {
  try {
    const response = await fetch(`${API_BASE}/admin/works/${id}`, {
      method: 'DELETE',
      headers: getAuthHeaders()
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '删除作品失败')
    }
  } catch (error) {
    console.error('Delete work error:', error)
    throw error
  }
}

// 文章管理API
export const getAdminPosts = async (): Promise<Post[]> => {
  try {
    const response = await fetch(`${API_BASE}/admin/posts`, {
      headers: getAuthHeaders()
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '获取文章列表失败')
    }
    return await response.json()
  } catch (error) {
    console.error('Get admin posts error:', error)
    throw error
  }
}

export const fetchPosts = async (): Promise<Post[]> => {
  try {
    const response = await fetch(`${API_BASE}/posts`)
    if (!response.ok) throw new Error('Failed to fetch posts')
    return await response.json()
  } catch (error) {
    console.error('Error fetching posts:', error)
    return []
  }
}

export const fetchPost = async (id: string): Promise<Post> => {
  try {
    const response = await fetch(`${API_BASE}/posts/${id}`)
    if (!response.ok) throw new Error('Failed to fetch post')
    return await response.json()
  } catch (error) {
    console.error(`Error fetching post ${id}:`, error)
    return {
      id: id,
      title: '默认文章',
      category: '默认分类',
      date: '2024-01-01'
    }
  }
}

export const createPost = async (postData: Omit<Post, 'id'>): Promise<void> => {
  try {
    const response = await fetch(`${API_BASE}/admin/posts`, {
      method: 'POST',
      headers: getAuthHeaders(),
      body: JSON.stringify(postData)
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '创建文章失败')
    }
  } catch (error) {
    console.error('Create post error:', error)
    throw error
  }
}

export const updatePost = async (id: string, postData: Omit<Post, 'id'>): Promise<void> => {
  try {
    const response = await fetch(`${API_BASE}/admin/posts/${id}`, {
      method: 'PUT',
      headers: getAuthHeaders(),
      body: JSON.stringify(postData)
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '更新文章失败')
    }
  } catch (error) {
    console.error('Update post error:', error)
    throw error
  }
}

export const deletePost = async (id: string): Promise<void> => {
  try {
    const response = await fetch(`${API_BASE}/admin/posts/${id}`, {
      method: 'DELETE',
      headers: getAuthHeaders()
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '删除文章失败')
    }
  } catch (error) {
    console.error('Delete post error:', error)
    throw error
  }
}

// 文章历史记录API
export const getPostHistory = async (postId: string): Promise<PostHistory[]> => {
  try {
    const response = await fetch(`${API_BASE}/admin/posts/${postId}/history`, {
      headers: getAuthHeaders()
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '获取文章历史失败')
    }
    return await response.json()
  } catch (error) {
    console.error('Get post history error:', error)
    throw error
  }
}

export const getPostHistoryByVersion = async (postId: string, version: number): Promise<PostHistory> => {
  try {
    const response = await fetch(`${API_BASE}/admin/posts/${postId}/history/${version}`, {
      headers: getAuthHeaders()
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '获取指定版本文章历史失败')
    }
    return await response.json()
  } catch (error) {
    console.error('Get post history by version error:', error)
    throw error
  }
}

// 代码片段管理API
export const getAdminSnippets = async (): Promise<Snippet[]> => {
  try {
    const response = await fetch(`${API_BASE}/admin/snippets`, {
      headers: getAuthHeaders()
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '获取代码片段列表失败')
    }
    return await response.json()
  } catch (error) {
    console.error('Get admin snippets error:', error)
    throw error
  }
}

export const fetchSnippets = async (): Promise<Snippet[]> => {
  try {
    const response = await fetch(`${API_BASE}/snippets`)
    if (!response.ok) throw new Error('Failed to fetch snippets')
    return await response.json()
  } catch (error) {
    console.error('Error fetching snippets:', error)
    return []
  }
}

export const fetchSnippet = async (id: string): Promise<Snippet> => {
  try {
    const response = await fetch(`${API_BASE}/snippets/${id}`)
    if (!response.ok) throw new Error('Failed to fetch snippet')
    return await response.json()
  } catch (error) {
    console.error(`Error fetching snippet ${id}:`, error)
    return {
      id: id,
      title: '默认代码片段',
      code: 'console.log("Hello World");',
      type: 'js'
    }
  }
}

export const createSnippet = async (snippetData: Omit<Snippet, 'id' | 'viewCount'>): Promise<void> => {
  try {
    const response = await fetch(`${API_BASE}/admin/snippets`, {
      method: 'POST',
      headers: getAuthHeaders(),
      body: JSON.stringify(snippetData)
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '创建代码片段失败')
    }
  } catch (error) {
    console.error('Create snippet error:', error)
    throw error
  }
}

export const updateSnippet = async (id: string, snippetData: Omit<Snippet, 'id' | 'viewCount'>): Promise<void> => {
  try {
    const response = await fetch(`${API_BASE}/admin/snippets/${id}`, {
      method: 'PUT',
      headers: getAuthHeaders(),
      body: JSON.stringify(snippetData)
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '更新代码片段失败')
    }
  } catch (error) {
    console.error('Update snippet error:', error)
    throw error
  }
}

export const deleteSnippet = async (id: string): Promise<void> => {
  try {
    const response = await fetch(`${API_BASE}/admin/snippets/${id}`, {
      method: 'DELETE',
      headers: getAuthHeaders()
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '删除代码片段失败')
    }
  } catch (error) {
    console.error('Delete snippet error:', error)
    throw error
  }
}

// 系统配置API
export const getSettings = async (): Promise<Setting[]> => {
  try {
    const response = await fetch(`${API_BASE}/admin/settings`, {
      headers: getAuthHeaders()
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '获取系统配置失败')
    }
    return await response.json()
  } catch (error) {
    console.error('Get settings error:', error)
    throw error
  }
}

export const createSetting = async (settingData: Omit<Setting, 'id' | 'createdAt' | 'updatedAt'>): Promise<void> => {
  try {
    const response = await fetch(`${API_BASE}/admin/settings`, {
      method: 'POST',
      headers: getAuthHeaders(),
      body: JSON.stringify(settingData)
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '创建系统配置失败')
    }
  } catch (error) {
    console.error('Create setting error:', error)
    throw error
  }
}

export const updateSetting = async (settingData: Omit<Setting, 'createdAt' | 'updatedAt'>): Promise<void> => {
  try {
    const response = await fetch(`${API_BASE}/admin/settings`, {
      method: 'PUT',
      headers: getAuthHeaders(),
      body: JSON.stringify(settingData)
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '更新系统配置失败')
    }
  } catch (error) {
    console.error('Update setting error:', error)
    throw error
  }
}

export const deleteSetting = async (keyName: string): Promise<void> => {
  try {
    const response = await fetch(`${API_BASE}/admin/settings/${keyName}`, {
      method: 'DELETE',
      headers: getAuthHeaders()
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '删除系统配置失败')
    }
  } catch (error) {
    console.error('Delete setting error:', error)
    throw error
  }
}

// 操作日志API
export const getOperationLogs = async (page: number = 1, pageSize: number = 10): Promise<PaginationResponse<OperationLog>> => {
  try {
    const response = await fetch(`${API_BASE}/admin/operation-logs?page=${page}&pageSize=${pageSize}`, {
      headers: getAuthHeaders()
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '获取操作日志失败')
    }
    return await response.json()
  } catch (error) {
    console.error('Get operation logs error:', error)
    throw error
  }
}

// 仪表盘数据类型
export interface DashboardStats {
  users: number
  posts: number
  works: number
  snippets: number
}

// 最近活动类型
export interface RecentActivity {
  id: number
  icon: string
  text: string
  time: string
}

// 仪表盘API
export const getDashboardStats = async (): Promise<DashboardStats> => {
  try {
    const response = await fetch(`${API_BASE}/admin/dashboard/stats`, {
      headers: getAuthHeaders()
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '获取仪表盘统计数据失败')
    }
    return await response.json()
  } catch (error) {
    console.error('Get dashboard stats error:', error)
    throw error
  }
}

// 获取最近活动
export const getRecentActivities = async (): Promise<RecentActivity[]> => {
  try {
    const response = await fetch(`${API_BASE}/admin/dashboard/activities`, {
      headers: getAuthHeaders()
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '获取最近活动失败')
    }
    return await response.json()
  } catch (error) {
    console.error('Get recent activities error:', error)
    throw error
  }
}

// 标签相关类型
export interface Tag {
  id: number
  name: string
  description: string
  createdAt: string
  updatedAt: string
}

// 标签管理API
export const adminGetTags = async (): Promise<Tag[]> => {
  try {
    const response = await fetch(`${API_BASE}/admin/tags`, {
      headers: getAuthHeaders()
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '获取标签列表失败')
    }
    return await response.json()
  } catch (error) {
    console.error('Get admin tags error:', error)
    throw error
  }
}

export const adminGetTag = async (id: number): Promise<Tag> => {
  try {
    const response = await fetch(`${API_BASE}/admin/tags/${id}`, {
      headers: getAuthHeaders()
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '获取标签详情失败')
    }
    return await response.json()
  } catch (error) {
    console.error('Get admin tag error:', error)
    throw error
  }
}

export const createTag = async (tagData: Omit<Tag, 'id' | 'createdAt' | 'updatedAt'>): Promise<void> => {
  try {
    const response = await fetch(`${API_BASE}/admin/tags`, {
      method: 'POST',
      headers: getAuthHeaders(),
      body: JSON.stringify(tagData)
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '创建标签失败')
    }
  } catch (error) {
    console.error('Create tag error:', error)
    throw error
  }
}

export const updateTag = async (id: number, tagData: Omit<Tag, 'id' | 'createdAt' | 'updatedAt'>): Promise<void> => {
  try {
    const response = await fetch(`${API_BASE}/admin/tags/${id}`, {
      method: 'PUT',
      headers: getAuthHeaders(),
      body: JSON.stringify(tagData)
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '更新标签失败')
    }
  } catch (error) {
    console.error('Update tag error:', error)
    throw error
  }
}

export const deleteTag = async (id: number): Promise<void> => {
  try {
    const response = await fetch(`${API_BASE}/admin/tags/${id}`, {
      method: 'DELETE',
      headers: getAuthHeaders()
    })
    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(errorData.error || '删除标签失败')
    }
  } catch (error) {
    console.error('Delete tag error:', error)
    throw error
  }
}