SuZhouGuanHong/ShanMeiXinNengYuan.git

import axios from 'axios'
import type {
  InstanceListItem,
  InstanceState,
  InstanceConfig,
  ProtocolTemplate,
  RobotClientStartRequest,
  RobotClientSendRequest,
  RobotClientStatusResponse
} from '../types'
 
const api = axios.create({
  baseURL: import.meta.env.VITE_API_BASE_URL || '/api',
  headers: {
    'Content-Type': 'application/json'
  }
})
 
// 获取所有实例
export async function getAllInstances(): Promise<InstanceListItem[]> {
  const response = await api.get<InstanceListItem[]>('/SimulatorInstances/GetAll')
  return response.data
}
 
// 获取实例状态
export async function getInstance(id: string): Promise<InstanceState | null> {
  try {
    const response = await api.get<InstanceState>('/SimulatorInstances/GetInstance', {
      params: { id }
    })
    return response.data
  } catch (error) {
    if (axios.isAxiosError(error) && error.response?.status === 404) {
      return null
    }
    throw error
  }
}
 
// 获取实例配置
export async function getInstanceConfig(id: string): Promise<InstanceConfig | null> {
  try {
    const response = await api.get<InstanceConfig>('/SimulatorInstances/GetInstanceConfig', {
      params: { id }
    })
    return response.data
  } catch (error) {
    if (axios.isAxiosError(error) && error.response?.status === 404) {
      return null
    }
    throw error
  }
}
 
// 创建实例
export async function createInstance(config: InstanceConfig): Promise<InstanceState | null> {
  try {
    const response = await api.post<InstanceState>('/SimulatorInstances/Create', config)
    return response.data
  } catch (error) {
    console.error('创建实例失败:', error)
    return null
  }
}
 
// 更新实例
export async function updateInstance(id: string, config: InstanceConfig): Promise<InstanceState | null> {
  try {
    const response = await api.put<InstanceState>('/SimulatorInstances/Update', config, {
      params: { id }
    })
    return response.data
  } catch (error) {
    console.error('更新实例失败:', error)
    return null
  }
}
 
// 删除实例
export async function deleteInstance(id: string, deleteConfig: boolean = true): Promise<boolean> {
  try {
    await api.delete('/SimulatorInstances/Delete', {
      params: { id, deleteConfig }
    })
    return true
  } catch (error) {
    console.error('删除实例失败:', error)
    return false
  }
}
 
// 启动实例
export async function startInstance(id: string): Promise<InstanceState | null> {
  try {
    const response = await api.post<InstanceState>('/SimulatorInstances/start', null, {
      params: { id }
    })
    return response.data
  } catch (error) {
    console.error('启动实例失败:', error)
    return null
  }
}
 
// 停止实例
export async function stopInstance(id: string): Promise<InstanceState | null> {
  try {
    const response = await api.post<InstanceState>('/SimulatorInstances/stop', null, {
      params: { id }
    })
    return response.data
  } catch (error) {
    console.error('停止实例失败:', error)
    return null
  }
}
 
// 重启实例
export async function restartInstance(id: string): Promise<InstanceState | null> {
  try {
    const response = await api.post<InstanceState>('/SimulatorInstances/restart', null, {
      params: { id }
    })
    return response.data
  } catch (error) {
    console.error('重启实例失败:', error)
    return null
  }
}
 
export async function getProtocolTemplates(): Promise<ProtocolTemplate[]> {
  const response = await api.get<ProtocolTemplate[]>('/ProtocolTemplates')
  return response.data
}
 
export async function getProtocolTemplate(id: string): Promise<ProtocolTemplate | null> {
  try {
    const response = await api.get<ProtocolTemplate>(`/ProtocolTemplates/${id}`)
    return response.data
  } catch (error) {
    if (axios.isAxiosError(error) && error.response?.status === 404) {
      return null
    }
    throw error
  }
}
 
export async function createProtocolTemplate(template: ProtocolTemplate): Promise<ProtocolTemplate> {
  const response = await api.post<ProtocolTemplate>('/ProtocolTemplates', template)
  return response.data
}
 
export async function updateProtocolTemplate(id: string, template: ProtocolTemplate): Promise<ProtocolTemplate> {
  const response = await api.put<ProtocolTemplate>(`/ProtocolTemplates/${id}`, template)
  return response.data
}
 
export async function deleteProtocolTemplate(id: string): Promise<void> {
  await api.delete(`/ProtocolTemplates/${id}`)
}
 
export async function readMemory(id: string): Promise<Record<string, string>> {
  const response = await api.get<Record<string, string>>('/Memory/ReadMemory', {
    params: { id }
  })
  return response.data
}
 
export async function writeMemory(id: string, data: Record<string, string>): Promise<boolean> {
  try {
    await api.post('/Memory/WriteMemory', data, {
      params: { id }
    })
    return true
  } catch (error) {
    console.error('写入内存失败:', error)
    return false
  }
}
 
// 获取机械手服务端运行状态（包含多实例和接收消息日志）
export async function getRobotClientStatus(): Promise<RobotClientStatusResponse> {
  const response = await api.get<RobotClientStatusResponse>('/RobotClients/status')
  return response.data
}
 
// 启动一个机械手服务端实例
export async function startRobotClients(request: RobotClientStartRequest): Promise<RobotClientStatusResponse> {
  const response = await api.post<RobotClientStatusResponse>('/RobotClients/start', request)
  return response.data
}
 
// 停止机械手服务端，serverId 为空时停止全部
export async function stopRobotClients(serverId?: string): Promise<void> {
  await api.post('/RobotClients/stop', null, {
    params: { serverId }
  })
}
 
// 发送机械手消息（按服务端实例广播或单发）
export async function sendRobotClientMessage(request: RobotClientSendRequest): Promise<void> {
  await api.post('/RobotClients/send', request)
}
 
// 清空指定服务端实例的接收消息日志
export async function clearRobotClientReceivedMessages(serverId: string): Promise<void> {
  await api.post('/RobotClients/clear-received', null, {
    params: { serverId }
  })
}
 
export default api