cunkebao_v3/nkebao/src/api/scenarios.ts

import { get, del, post,put } from './request';
import type { ApiResponse } from '@/types/common';

// 服务器返回的场景数据类型
export interface SceneItem {
  id: number;
  name: string;
  image: string;
  status: number;
  createTime: number;
  updateTime: number | null;
  deleteTime: number | null;
}

// 前端使用的场景数据类型
export interface Channel {
  id: string;
  name: string;
  icon: string;
  stats: {
    daily: number;
    growth: number;
  };
  link?: string;
  plans?: Plan[];
}

// 计划类型
export interface Plan {
  id: string;
  name: string;
  isNew?: boolean;
  status: "active" | "paused" | "completed";
  acquisitionCount: number;
}

// 任务类型
export interface Task {
  id: string;
  name: string;
  status: number;
  stats: {
    devices: number;
    acquired: number;
    added: number;
  };
  lastUpdated: string;
  executionTime: string;
  nextExecutionTime: string;
  trend: { date: string; customers: number }[];
}

// 消息内容类型
export interface MessageContent {
  id: string;
  type: string; // "text" | "image" | "video" | "file" | "miniprogram" | "link" | "group" 等
  content?: string;
  intervalUnit?: "seconds" | "minutes";
  sendInterval?: number;
  // 其他可选字段
  [key: string]: any;
}

// 每天的消息计划
export interface MessagePlan {
  day: number;
  messages: MessageContent[];
}

// 海报类型
export interface Poster {
  id: string;
  name: string;
  type: string;
  preview: string;
}

// 标签类型
export interface Tag {
  id: string;
  name: string;
  [key: string]: any;
}

// textUrl类型
export interface TextUrl {
  apiKey: string;
  originalString?: string;
  sign?: string;
  fullUrl: string;
}

// 计划详情类型
export interface PlanDetail {
  id: number;
  name: string;
  scenario: number;
  scenarioTags: Tag[];
  customTags: Tag[];
  posters: Poster[];
  device: string[];
  enabled: boolean;
  addInterval: number;
  remarkFormat: string;
  endTime: string;
  greeting: string;
  startTime: string;
  remarkType: string;
  addFriendInterval: number;
  messagePlans: MessagePlan[];
  sceneId: number | string;
  userId: number;
  companyId: number;
  status: number;
  apiKey: string;
  wxMinAppSrc?: any;
  textUrl: TextUrl;
  [key: string]: any;
}

/**
 * 获取获客场景列表
 * 
 * @param params 查询参数
 * @returns 获客场景列表
 */
export const fetchScenes = async (params: {
  page?: number;
  limit?: number;
  keyword?: string;
} = {}): Promise<ApiResponse<SceneItem[]>> => {
  const { page = 1, limit = 10, keyword = "" } = params;
  
  const queryParams = new URLSearchParams();
  queryParams.append("page", String(page));
  queryParams.append("limit", String(limit));
  
  if (keyword) {
    queryParams.append("keyword", keyword);
  }
  
  try {
    return await get<ApiResponse<SceneItem[]>>(`/v1/plan/scenes?${queryParams.toString()}`);
  } catch (error) {
    console.error("Error fetching scenes:", error);
    // 返回一个错误响应
    return {
      code: 500,
      msg: "获取场景列表失败",
      data: []
    };
  }
};

/**
 * 获取场景详情
 * 
 * @param id 场景ID
 * @returns 场景详情
 */
export const fetchSceneDetail = async (id: string | number): Promise<ApiResponse<SceneItem>> => {
  try {
    return await get<ApiResponse<SceneItem>>(`/v1/plan/scenes/${id}`);
  } catch (error) {
    console.error("Error fetching scene detail:", error);
    return {
      code: 500,
      msg: "获取场景详情失败",
      data: null
    };
  }
};

/**
 * 获取场景名称
 * 
 * @param channel 场景标识
 * @returns 场景名称
 */
export const fetchSceneName = async (channel: string): Promise<ApiResponse<{ name: string }>> => {
  try {
    return await get<ApiResponse<{ name: string }>>(`/v1/plan/scenes-detail?id=${channel}`);
  } catch (error) {
    console.error("Error fetching scene name:", error);
    return {
      code: 500,
      msg: "获取场景名称失败",
      data: { name: channel }
    };
  }
};

/**
 * 获取计划列表
 * 
 * @param channel 场景标识
 * @param page 页码
 * @param pageSize 每页数量
 * @returns 计划列表
 */
export const fetchPlanList = async (
  channel: string, 
  page: number = 1, 
  pageSize: number = 10
): Promise<ApiResponse<{ list: Task[]; total: number }>> => {
  try {
    return await get<ApiResponse<{ list: Task[]; total: number }>>(
      `/v1/plan/list?sceneId=${channel}&page=${page}&pageSize=${pageSize}`
    );
  } catch (error) {
    console.error("Error fetching plan list:", error);
    return {
      code: 500,
      msg: "获取计划列表失败",
      data: { list: [], total: 0 }
    };
  }
};

/**
 * 复制计划
 * 
 * @param planId 计划ID
 * @returns 复制结果
 */
export const copyPlan = async (planId: string): Promise<ApiResponse<any>> => {
  try {
    return await get<ApiResponse<any>>(`/v1/plan/copy?planId=${planId}`);
  } catch (error) {
    console.error("Error copying plan:", error);
    return {
      code: 500,
      msg: "复制计划失败",
      data: null
    };
  }
};

/**
 * 删除计划
 * 
 * @param planId 计划ID
 * @returns 删除结果
 */
export const deletePlan = async (planId: string): Promise<ApiResponse<any>> => {
  try {
    return await del<ApiResponse<any>>(`/v1/plan/delete?planId=${planId}`);
  } catch (error) {
    console.error("Error deleting plan:", error);
    return {
      code: 500,
      msg: "删除计划失败",
      data: null
    };
  }
};

/**
 * 获取计划详情
 * 
 * @param planId 计划ID
 * @returns 计划详情
 */
export const fetchPlanDetail = async (planId: string): Promise<ApiResponse<PlanDetail>> => {
  try {
    return await get<ApiResponse<PlanDetail>>(`/v1/plan/detail?planId=${planId}`);
  } catch (error) {
    console.error("Error fetching plan detail:", error);
    return {
      code: 500,
      msg: "获取计划详情失败",
      data: null
    };
  }
};

/**
 * 将服务器返回的场景数据转换为前端展示需要的格式
 * 
 * @param item 服务器返回的场景数据
 * @returns 前端展示的场景数据
 */
export const transformSceneItem = (item: SceneItem): Channel => {
  // 为每个场景生成随机的"今日"数据和"增长百分比"
  const dailyCount = Math.floor(Math.random() * 100);
  const growthPercent = Math.floor(Math.random() * 40) - 10; // -10% 到 30% 的随机值
  
  // 默认图标(如果服务器没有返回)
  const defaultIcon = "/assets/icons/poster-icon.svg";
  
  return {
    id: String(item.id),
    name: item.name,
    icon: item.image || defaultIcon,
    stats: {
      daily: dailyCount,
      growth: growthPercent
    }
  };
}; 

export const getPlanScenes = () => get<any>('/v1/plan/scenes'); 

export async function createScenarioPlan(data: any) {
  return post('/v1/plan/create', data);
} 

// 编辑计划
export async function updateScenarioPlan(planId: number | string, data: any) {
  return await put(`/v1/plan/update?planId=${planId}`, data);
}