import type { LogFunc, RequestHeader } from './common';
import type { SocketMessageInterface } from './socket';

/**
 * session 的错误配置
 * deprecated，参数在业务方自己处理
 *
 * @export
 * @enum {string}
 */
export enum SessionErrorCode {
  SESSION_CLOSED = 'session.status.closed', // session 被关闭
  CONNECT_SESSION_TIMEOUT = 'connect session timeout', // 连接 session 超时
  SESSION_OPENAI_ERROR = 'session.openai.error', // session openai 错误
  SERVICE_STATUS_UNAVAILABLE = 'service.status.unavailable', // 服务不可用
  SESSION_MESSAGE_EXCEED_REQUEST_LIMIT = 'session.message.exceedRequestLimit', //超过消息发送频次

  PACKAGE_TURN_EXHAUSTION = 'package.turn.exhaustion', // 计费达到上限
  SESSION_MESSAGE_EXCEED_QPS_LIMIT = 'session.message.exceedQPSLimit', //QPS 超过上限 - MindOS
  UMM_MSG_EXCEED_QPS_LIMIT = 'umm.msg.exceedQPSLimit', // QPS 超过上限 - UMM

  SESSION_RESPONSE_TIMEOUT = 'session.response.timeout', // session 返回超时
  FREE_USED_UP_BYOK_PLAN = 'freeUsedUp.byokPlan', // 免费额度用完
  MESSAGE_LENGTH_LIMIT = 'message.length.limit' // 消息长度超过限制
}

export enum SENDER_TYPE {
  umm = 'umm',
  client = 'client'
}

/**
 * data 结构类型
 */
export enum WS_MSG_DATA_TYPE {
  text = 'text',
  template = 'template'
}

/**
 * 前端自己处理的错误码，比如说 ws 建立存在异常，需要在 session 侧展示
 */
export enum FRONTEND_ERROR_CODE {
  WS_CONNECT_ERROR = 'ws.connect.error' // ws 建立连接失败
}

/**
 * session 出错后的行为配置
 * 从chat-container复制而来，参数在业务方维护
 *
 * @export
 * @enum {string}
 */

export enum ChatSessionSubCodeAction {
  RESTART_SESSION = 'restartSession', // 红色，点击后重启 session
  RESEND_MSG = 'resendMessage', // 黄色，点击后重发当前消息
  SIMPLE_HINT = 'simpleHint', // 灰色系统消息，类似于 Genius Update
  OPEN_PAGE = 'openPage' // BYOK 等特定行为，用于页面的打开灯逻辑。
}

/**
 * Session 会话需要的链接
 */
export interface SessionURLConfig {
  openPath: string;
  closePath: string;
  sendMsgPath: string;
  fetchMsgPath: string; // 往前或者往后搜索历史记录
  fetchLastMsgPath: string; // 请求最近一条消息的 seqId
}

/**
 * Session 会话需要的参数
 */
export interface SessionConnectConfig {
  deviceId: string;
}

/**
 * 当前心识类型
 */
export enum WS_MIND_TYPE {
  shadow = 'shadow', // 未发布的影子心识
  original = 'original' //  发布的正式心识
}

/**
 * 当前心识模式
 */
export enum MIND_MODE {
  NORMAL = 'NORMAL',
  PERSONAL = 'PERSONAL', // PA
  SELF = 'SELF' // 之前为了兼容 GPT-4 单独开的口子，现在基本不用了。
}

/**
 * 用户发送的纯文本消息
 *
 * @export
 * @interface WS_DATA_TYPE_TEXT
 */
export interface WS_DATA_TYPE_TEXT {
  content: string; //用户输入文本
  urls?: string[]; // 用户追加的多模态文件
}

/**
 * 用户发送的图片（现阶段是否使用不确定，需要 @jinkai 确认）
 *
 * @export
 * @interface WS_DATA_TYPE_IMG
 */
export interface WS_DATA_TYPE_IMG {
  base64: string; //图片的base64数据
}

/**
 * 用户发送的画图 AIGC（现阶段是否使用不确定，需要 @jinkai 确认）
 *
 * @export
 * @interface WS_DATA_TYPE_AIGC
 */
export interface WS_DATA_TYPE_AIGC {
  isPolling: boolean; //是否发起轮询，用于画画等skill
}

/**
 * 用户发送的消息类型，通用定义，方便外部使用
 */
export type SEND_MSG_TYPE =
  | WS_DATA_TYPE_AIGC
  | WS_DATA_TYPE_IMG
  | WS_DATA_TYPE_TEXT;

/**
 * Session 发送消息的数据结构，给 socket 的数据结构
 *
 * @export
 * @interface SessionSendMessageModel
 */
export interface SessionSendMessageModel {
  messageId?: string;
  type: SessionMessageType;
  sessionId: string;
  refUserId?: string;
  wsId: string;
  data?: SEND_MSG_TYPE; // 只有 ACK 的时候是 undefined
  canvasInfo?: CanvasInfo[];
}

/**
 * 画图状态
 */
export enum WS_MSG_MULTIPLE_IMG_STATUS {
  PROCESSING = 'PROCESSING', // 正在画图中
  FINISH = 'FINISH' // 画图完成
}

/**
 * 多模态数据结构
 *
 * @export
 * @interface WS_MSG_MULTIPLE_MODAL
 */
export interface WS_MSG_MULTIPLE_MODAL {
  answer?: string;
  speech?: string;
  template?: string;
}

/**
 * 多模态数据类型定义
 */
export interface WS_MSG_MULTIPLE_DATA {
  singleDataType: WS_MSG_DATA_TYPE;
  modal: WS_MSG_MULTIPLE_MODAL;
}

export enum SessionMessageType {
  msg = 'msg',
  hint = 'hint',
  sys = 'sys', // 异常消息，统一通过 sys 给回来
  recommend = 'recommend' // 推荐心识
}

export function isSessionMessage(msg: SocketMessageInterface): boolean {
  const sessionType = Object.values(SessionMessageType) as string[];

  return sessionType.includes(msg.type);
}

/**
 * Session 返回的消息数据结构
 *
 * @export
 * @interface SessionMessageModel
 * @extends {SocketMessageBasicType}
 */
export interface SessionMessageModel extends SocketMessageInterface {
  sender: SENDER_TYPE;
  subCode?: string;
  subCodeReason?: string;
  subCodeActions?: string[];
  timestamp: number;
  type: SessionMessageType;
  index: number;
  mindId: string;
  sessionId: string;
  messageId: string;
  seqId: string;
  apiVersion?: string;
  sdkVersion?: string;
  multipleData: WS_MSG_MULTIPLE_DATA[];
  data: SEND_MSG_TYPE;
  canvasInfo?: CanvasInfo[];
}

/**
 * Session 用户的快捷消息结构
 *
 * @export
 * @interface CreateSessionSentence
 */
export interface CreateSessionSentence {
  open: boolean;
  firstOfUser: string[];
}

/**
 * 需要引用的 canvas 信息
 */
export interface CanvasInfo {
  fileDocId: string;
  canvasId: string;
  type: string;
  title: string;
  quote?: string[];
  images?: string[];
}

/**
 * Session 发送消息的数据结构，外部调用传入
 *
 * @export
 * @interface SessionSendModel
 */
export interface SessionSendModel {
  dataType: WS_MSG_DATA_TYPE;
  data: SEND_MSG_TYPE; // 只有 ACK 的时候是 undefined
  canvasInfo?: CanvasInfo[];
}

/**
 * session 消息的回调逻辑
 *
 * @export
 * @interface SessionMessageCallbackObject
 */
export interface SessionMessageCallbackObject {
  /**
   * 收到的消息（包括中间步骤）
   *
   * @memberof SessionMessageCallbackObject
   */
  onMsgUpdateListener?: (msgList: SessionMessageModel[]) => void;

  /**
   * 收到的错误消息
   *
   * @memberof SessionMessageCallbackObject
   */
  onErrorListener?: (errorMsg: ErrorMsg) => void;
}

/**
 * Session 的生命周期回调接口
 *
 * @export
 * @interface SessionLifeCycleModel
 */
export interface SessionLifeCycleModel {
  /**
   * session 创建之后的回调，用于处理删除逻辑。
   *
   * @memberof SessionLifeCycleModel
   */
  sessionClose?: (sessionId?: string) => void;

  /**
   * session 日志消息展示
   *
   * @type {LogFunc}
   * @memberof SessionLifeCycleModel
   */
  log?: LogFunc;
}

/**
 * 开启 session 的配置参数
 *
 * @export
 * @interface OpenSessionModel
 */
export interface OpenSessionModel {
  deviceId: string;
  mindId: string;
  mindType: WS_MIND_TYPE;
  mode: MIND_MODE;
}

export interface SessionMindInfo {
  mindId: string;
  mindType: WS_MIND_TYPE;
  mode: MIND_MODE;
}

/**
 * Session 的基本信息
 *
 * @export
 * @interface SessionDataInfo
 */
export interface SessionDataInfo extends SessionMindInfo {
  sessionId: string;
  sentence?: CreateSessionSentence;
  validFileScheme?: string; // 支持上传的能力
  openSessionTime?: number;
  openSessionCount?: number;
  confirmSessionTime?: number;
}

/**
 * Socket 对象配置参数
 */
export interface SessionConfig {
  baseUrl: string;
  header: RequestHeader;
  config: OpenSessionModel;
  deviceId: string;
  refUserId: string;
  urlConfigModel: SessionURLConfig;
  lifeCycle: SessionLifeCycleModel;
  callback: SessionMessageCallbackObject;
  log?: LogFunc;
}

/** Session 最大重试次数 */
export const MAX_RETRY_COUNT = 10;

/** 自定义错误消息 */
export interface ErrorMsg {
  subCode: string;
  subCodeReason?: string;
  subCodeActions?: string[];
  messageId?: string;
  seqId?: string;
}

export interface OpenSessionResult {
  sessionId: string;
  retryCount?: number;
}

export interface SessionInterface {
  callback: SessionMessageCallbackObject;
  sessionData: SessionDataInfo;

  receiveMsgFromSocket: (data: SessionMessageModel) => void;
  waitingForStart: () => void;
  startReceiveMsg: () => Promise<void>;
  sendMsg(msg: SessionSendModel, wsId: string): Promise<void>;
  fetchSessionMsg(data: {
    history: boolean;
    msgList?: SessionMessageModel[];
    seqId?: string;
  }): Promise<SessionMessageModel[]>;
  appendErrorMsg: (data: ErrorMsg) => void;
}