import * as crypto from 'node:crypto';
import * as zlib from 'node:zlib';
import { NapProtoDecodeStructType, NapProtoEncodeStructType, NapProtoMsg } from 'napcat-protobuf';
import {
  CustomFace,
  Elem,
  FileExtra,
  GroupFileExtra,
  MarkdownData,
  MentionExtra,
  MsgInfo,
  NotOnlineImage,
  OidbSvcTrpcTcp0XE37_800Response,
  PushMsgBody,
  QBigFaceExtra,
  QSmallFaceExtra,
} from '@/napcat-core/packet/transformer/proto';
import {
  ElementType,
  FaceType,
  MessageElement,
  NTMsgAtType,
  NTVideoType,
  PicType,
  Peer,
} from '@/napcat-core/types/msg';
import {
  SendArkElement,
  SendFaceElement,
  SendFileElement,
  SendMarkdownElement,
  SendMarketFaceElement,
  SendPicElement,
  SendPttElement,
  SendReplyElement,
  SendMultiForwardMsgElement,
  SendTextElement,
  SendVideoElement,
} from '@/napcat-core/types/element';
import { ForwardMsgBuilder } from '@/napcat-core/helper/forward-msg-builder';
import { PacketMsg, PacketSendMsgElement } from '@/napcat-core/packet/message/message';

export type ParseElementFnR = [MessageElement, NapProtoDecodeStructType<typeof Elem> | null] | undefined;
type ParseElementFn = (elem: NapProtoDecodeStructType<typeof Elem>) => ParseElementFnR;

// raw <-> packet
// TODO: SendStructLongMsgElement
export abstract class IPacketMsgElement<T extends PacketSendMsgElement> {
  protected constructor (_rawElement: T) {
  }

  get valid (): boolean {
    return true;
  }

  buildContent (): Uint8Array | undefined {
    return undefined;
  }

  buildElement (): NapProtoEncodeStructType<typeof Elem>[] {
    return [];
  }

  static parseElement: ParseElementFn;

  toPreview (): string {
    return '[暂不支持该消息类型喵~]';
  }
}

export class PacketMsgTextElement extends IPacketMsgElement<SendTextElement> {
  text: string;

  constructor (element: SendTextElement) {
    super(element);
    this.text = element.textElement.content;
  }

  override buildElement (): NapProtoEncodeStructType<typeof Elem>[] {
    return [{
      text: {
        str: this.text,
      },
    }];
  }

  static override parseElement = (elem: NapProtoDecodeStructType<typeof Elem>): ParseElementFnR => {
    if (elem.text?.str && (elem.text?.attr6Buf === undefined || elem.text?.attr6Buf?.length === 0)) {
      return [{
        textElement: {
          content: elem.text?.str,
          atType: NTMsgAtType.ATTYPEUNKNOWN,
          atUid: '',
          atTinyId: '',
          atNtUid: '',
        },
        elementType: ElementType.UNKNOWN,
        elementId: '',
      }, null];
    }
    return undefined;
  };

  override toPreview (): string {
    return this.text;
  }
}

export class PacketMsgAtElement extends PacketMsgTextElement {
  targetUid: string;
  atAll: boolean;

  constructor (element: SendTextElement) {
    super(element);
    this.targetUid = element.textElement.atNtUid;
    this.atAll = element.textElement.atType === NTMsgAtType.ATTYPEALL;
  }

  override buildElement (): NapProtoEncodeStructType<typeof Elem>[] {
    return [{
      text: {
        str: this.text,
        pbReserve: new NapProtoMsg(MentionExtra).encode({
          type: this.atAll ? 1 : 2,
          uin: 0,
          field5: 0,
          uid: this.targetUid,
        }
        ),
      },
    }];
  }

  static override parseElement = (elem: NapProtoDecodeStructType<typeof Elem>): ParseElementFnR => {
    if (elem.text?.str && (elem.text?.attr6Buf?.length ?? 100) >= 11) {
      return [{
        textElement: {
          content: elem.text?.str,
          atType: NTMsgAtType.ATTYPEONE,
          atUid: String(Buffer.from(elem.text!.attr6Buf!).readUInt32BE(7)),  // FIXME: hack
          atTinyId: '',
          atNtUid: '',
        },
        elementType: ElementType.UNKNOWN,
        elementId: '',
      }, null];
    }
    return undefined;
  };
}

export class PacketMsgReplyElement extends IPacketMsgElement<SendReplyElement> {
  time: number;
  targetMessageId: bigint;
  targetMessageSeq: number;
  targetMessageClientSeq: number;
  targetUin: number;
  targetUid: string;
  targetElems?: NapProtoEncodeStructType<typeof Elem>[];
  targetSourceMsg?: NapProtoEncodeStructType<typeof PushMsgBody>;
  targetPeer?: Peer;

  constructor (element: SendReplyElement) {
    super(element);
    this.time = +(element.replyElement.replyMsgTime ?? Math.floor(Date.now() / 1000));
    this.targetMessageId = BigInt(element.replyElement.replayMsgId ?? 0);
    this.targetMessageSeq = +(element.replyElement.replayMsgSeq ?? 0);
    this.targetMessageClientSeq = +(element.replyElement.replyMsgClientSeq ?? 0);
    this.targetUin = +(element.replyElement.senderUin ?? 0);
    this.targetUid = element.replyElement.senderUidStr ?? '';
    this.targetPeer = element.replyElement._replyMsgPeer;
  }

  get isGroupReply (): boolean {
    return this.targetMessageClientSeq === 0;
  }

  override buildElement (): NapProtoEncodeStructType<typeof Elem>[] {
    return [{
      srcMsg: {
        origSeqs: [this.isGroupReply ? this.targetMessageSeq : this.targetMessageClientSeq],
        senderUin: BigInt(this.targetUin),
        time: this.time,
        elems: this.targetElems ?? [],
        sourceMsg: new NapProtoMsg(PushMsgBody).encode(this.targetSourceMsg ?? {}),
        toUin: BigInt(0),
      },
    }];
  }

  static override parseElement = (elem: NapProtoDecodeStructType<typeof Elem>): ParseElementFnR => {
    if (elem.srcMsg && elem.srcMsg.pbReserve) {
      const reserve = elem.srcMsg.pbReserve;
      return [{
        replyElement: {
          replayMsgSeq: String(reserve.friendSeq ?? elem.srcMsg?.origSeqs?.[0] ?? 0),
          replayMsgId: String(reserve.messageId ?? 0),
          senderUin: String(elem?.srcMsg ?? 0),
        },
        elementType: ElementType.UNKNOWN,
        elementId: '',
      }, null];
    }
    return undefined;
  };

  override toPreview (): string {
    return '[回复消息]';
  }
}

export class PacketMsgFaceElement extends IPacketMsgElement<SendFaceElement> {
  faceId: number;
  faceText: string;
  isLargeFace: boolean;
  resultId?: string;

  constructor (element: SendFaceElement) {
    super(element);
    this.faceId = element.faceElement.faceIndex;
    this.faceText = element.faceElement.faceText || '[表情]';
    this.resultId = element.faceElement.resultId;
    this.isLargeFace = element.faceElement.faceType === FaceType.AniSticke;
  }

  override buildElement (): NapProtoEncodeStructType<typeof Elem>[] {
    if (this.isLargeFace) {
      return [{
        commonElem: {
          serviceType: 37,
          pbElem: new NapProtoMsg(QBigFaceExtra).encode({
            aniStickerPackId: '1',
            aniStickerId: '8',
            faceId: this.faceId,
            sourceType: 1,
            resultId: this.resultId,
            preview: '',
            randomType: 1,
          }),
          businessType: 1,
        },
      }, {
        // QQ consumes the element after an animated face as compatibility text.
        // Without it, the next user-supplied message segment is discarded.
        text: {
          str: this.faceText,
        },
      }];
    } else if (this.faceId < 260) {
      return [{
        face: {
          index: this.faceId,
        },
      }];
    } else {
      return [{
        commonElem: {
          serviceType: 33,
          pbElem: new NapProtoMsg(QSmallFaceExtra).encode({
            faceId: this.faceId,
            preview: '',
            preview2: '',
          }),
          businessType: 1,
        },
      }];
    }
  }

  static override parseElement = (elem: NapProtoDecodeStructType<typeof Elem>): ParseElementFnR => {
    if (elem.face?.index) {
      return [{
        faceElement: {
          faceIndex: elem.face.index,
          faceType: FaceType.Normal,
        },
        elementType: ElementType.UNKNOWN,
        elementId: '',
      }, null];
    }
    if (elem?.commonElem?.serviceType === 37 && elem?.commonElem?.pbElem) {
      const qface = new NapProtoMsg(QBigFaceExtra).decode(elem?.commonElem?.pbElem);
      if (qface?.faceId) {
        return [{
          faceElement: {
            faceIndex: qface.faceId,
            faceType: FaceType.Normal,
          },
          elementType: ElementType.UNKNOWN,
          elementId: '',
        }, null];
      }
    }
    if (elem?.commonElem?.serviceType === 33 && elem?.commonElem?.pbElem) {
      const qface = new NapProtoMsg(QSmallFaceExtra).decode(elem?.commonElem?.pbElem);
      if (qface?.faceId) {
        return [{
          faceElement: {
            faceIndex: qface.faceId,
            faceType: FaceType.Normal,
          },
          elementType: ElementType.UNKNOWN,
          elementId: '',
        }, null];
      }
    }
    return undefined;
  };

  override toPreview (): string {
    return '[表情]';
  }
}

export class PacketMsgMarkFaceElement extends IPacketMsgElement<SendMarketFaceElement> {
  emojiName: string;
  emojiId: string;
  emojiPackageId: number;
  emojiKey: string;

  constructor (element: SendMarketFaceElement) {
    super(element);
    this.emojiName = element.marketFaceElement.faceName;
    this.emojiId = element.marketFaceElement.emojiId;
    this.emojiPackageId = element.marketFaceElement.emojiPackageId;
    this.emojiKey = element.marketFaceElement.key;
  }

  override buildElement (): NapProtoEncodeStructType<typeof Elem>[] {
    return [{
      marketFace: {
        faceName: this.emojiName,
        itemType: 6,
        faceInfo: 1,
        faceId: Buffer.from(this.emojiId, 'hex'),
        tabId: this.emojiPackageId,
        subType: 3,
        key: this.emojiKey,
        imageWidth: 300,
        imageHeight: 300,
        pbReserve: {
          field8: 1,
        },
      },
    }];
  }

  override toPreview (): string {
    return `${this.emojiName}`;
  }
}

export class PacketMsgPicElement extends IPacketMsgElement<SendPicElement> {
  path: string;
  name: string;
  size: number;
  md5: string;
  width: number;
  height: number;
  picType: PicType;
  picSubType: number;
  summary: string;
  sha1: string | null = null;
  msgInfo: NapProtoEncodeStructType<typeof MsgInfo> | null = null;
  groupPicExt: NapProtoEncodeStructType<typeof CustomFace> | null = null;
  c2cPicExt: NapProtoEncodeStructType<typeof NotOnlineImage> | null = null;

  constructor (element: SendPicElement) {
    super(element);
    this.path = element.picElement.sourcePath;
    this.name = element.picElement.fileName;
    this.size = +element.picElement.fileSize;
    this.md5 = element.picElement.md5HexStr ?? '';
    this.width = element.picElement.picWidth;
    this.height = element.picElement.picHeight;
    this.picType = element.picElement.picType;
    this.picSubType = element.picElement.picSubType ?? 0;
    this.summary = element.picElement.summary === ''
      ? (
        element.picElement.picSubType === 0 ? '[图片]' : '[动画表情]'
      )
      : element.picElement.summary;
  }

  override get valid (): boolean {
    return !!this.msgInfo;
  }

  override buildElement (): NapProtoEncodeStructType<typeof Elem>[] {
    if (!this.msgInfo) return [];
    return [{
      commonElem: {
        serviceType: 48,
        pbElem: new NapProtoMsg(MsgInfo).encode(this.msgInfo),
        businessType: 10,
      },
    }];
  }

  static override parseElement = (elem: NapProtoDecodeStructType<typeof Elem>): ParseElementFnR => {
    if (elem?.commonElem?.serviceType === 48 &&
      [10, 20].includes(elem.commonElem.businessType ?? 0) &&
      elem.commonElem.pbElem) {
      const extra = new NapProtoMsg(MsgInfo).decode(elem.commonElem.pbElem);
      const msgInfoBody = extra.msgInfoBody[0];
      const index = msgInfoBody?.index;
      return [{
        picElement: {
          fileSize: index?.info.fileSize ?? 0,
          picWidth: index?.info?.width ?? 0,
          picHeight: index?.info?.height ?? 0,
          fileName: index?.info?.fileHash ?? '',
          sourcePath: '',
          original: false,
          picType: PicType.NEWPIC_APNG,
          fileUuid: '',
          fileSubId: '',
          thumbFileSize: 0,
          summary: '[图片]',
          thumbPath: new Map(),
        },
        elementType: ElementType.PIC,
        elementId: '',
      }, elem];
    }
    if (elem?.notOnlineImage) {
      const img = elem?.notOnlineImage; // url in originImageUrl
      const preImg: MessageElement = {
        picElement: {
          fileSize: img.fileLen ?? 0,
          picWidth: img.picWidth ?? 0,
          picHeight: img.picHeight ?? 0,
          fileName: Buffer.from(img.picMd5!).toString('hex') ?? '',
          sourcePath: '',
          original: false,
          picType: PicType.NEWPIC_APNG,
          fileUuid: '',
          fileSubId: '',
          thumbFileSize: 0,
          summary: '[图片]',
          thumbPath: new Map(),
        },
        elementType: ElementType.UNKNOWN,
        elementId: '',
      };
      if (img.origUrl?.includes('&fileid=')) {
        preImg.picElement!.originImageUrl = `https://multimedia.nt.qq.com.cn${img.origUrl}`;
      } else {
        preImg.picElement!.originImageUrl = `https://gchat.qpic.cn${img.origUrl}`;
      }
      return [preImg, elem];
    }
    return undefined;
  };

  override toPreview (): string {
    return this.summary;
  }
}

export class PacketMsgVideoElement extends IPacketMsgElement<SendVideoElement> {
  fileName: string;
  fileSize?: string;
  filePath?: string;
  fileTime: number;
  fileFormat: NTVideoType;
  fileWidth?: number;
  fileHeight?: number;
  thumbSize?: number;
  thumbPath?: string;
  fileMd5?: string;
  fileSha1?: string;
  thumbMd5?: string;
  thumbSha1?: string;
  thumbWidth?: number;
  thumbHeight?: number;
  businessType: 11 | 21 = 21;
  msgInfo: NapProtoEncodeStructType<typeof MsgInfo> | null = null;

  constructor (element: SendVideoElement) {
    super(element);
    this.fileName = element.videoElement.fileName;
    this.fileSize = element.videoElement.fileSize;
    this.filePath = element.videoElement.filePath;
    this.fileTime = Math.max(0, Math.round(element.videoElement.fileTime ?? 0));
    this.fileFormat = element.videoElement.fileFormat ?? NTVideoType.VIDEO_FORMAT_MP4;
    this.fileWidth = element.videoElement.fileWidth;
    this.fileHeight = element.videoElement.fileHeight;
    this.thumbSize = element.videoElement.thumbSize;
    this.thumbPath = element.videoElement.thumbPath?.get(0) as string | undefined;
    this.fileMd5 = element.videoElement.videoMd5;
    this.thumbMd5 = element.videoElement.thumbMd5;
    this.thumbWidth = element.videoElement.thumbWidth;
    this.thumbHeight = element.videoElement.thumbHeight;
  }

  override get valid (): boolean {
    return !!this.msgInfo;
  }

  override buildElement (): NapProtoEncodeStructType<typeof Elem>[] {
    if (!this.msgInfo) return [];
    return [{
      commonElem: {
        serviceType: 48,
        pbElem: new NapProtoMsg(MsgInfo).encode(this.msgInfo),
        businessType: this.businessType,
      },
    }];
  }

  static override parseElement = (elem: NapProtoDecodeStructType<typeof Elem>): ParseElementFnR => {
    if (elem?.commonElem?.serviceType !== 48 ||
      ![11, 21].includes(elem.commonElem.businessType ?? 0) ||
      !elem.commonElem.pbElem) {
      return undefined;
    }
    const extra = new NapProtoMsg(MsgInfo).decode(elem.commonElem.pbElem);
    const videoIndex = extra.msgInfoBody[0]?.index;
    const thumbIndex = extra.msgInfoBody[1]?.index;
    if (!videoIndex) return undefined;
    return [{
      videoElement: {
        filePath: '',
        fileName: videoIndex.info.fileName || videoIndex.info.fileHash,
        videoMd5: videoIndex.info.fileHash,
        thumbMd5: thumbIndex?.info.fileHash,
        fileTime: videoIndex.info.time,
        fileFormat: (videoIndex.info.type.videoFormat || NTVideoType.VIDEO_FORMAT_MP4) as NTVideoType,
        fileSize: String(videoIndex.info.fileSize),
        fileWidth: videoIndex.info.width,
        fileHeight: videoIndex.info.height,
        thumbWidth: thumbIndex?.info.width,
        thumbHeight: thumbIndex?.info.height,
        thumbSize: thumbIndex?.info.fileSize,
        thumbPath: new Map(),
        fileUuid: videoIndex.fileUuid,
        busiType: 0,
        subBusiType: 0,
      },
      elementType: ElementType.VIDEO,
      elementId: '',
    }, elem];
  };

  override toPreview (): string {
    return '[视频]';
  }
}

export class PacketMsgPttElement extends IPacketMsgElement<SendPttElement> {
  filePath: string;
  fileSize: number;
  fileMd5: string;
  fileSha1?: string;
  fileDuration: number;
  msgInfo: NapProtoEncodeStructType<typeof MsgInfo> | null = null;

  constructor (element: SendPttElement) {
    super(element);
    this.filePath = element.pttElement.filePath;
    this.fileSize = +element.pttElement.fileSize; // TODO: cc
    this.fileMd5 = element.pttElement.md5HexStr;
    this.fileDuration = Math.round(element.pttElement.duration); // TODO: cc
  }

  override get valid (): boolean {
    return false;
  }

  override buildElement (): NapProtoEncodeStructType<typeof Elem>[] {
    // return [];
    if (!this.msgInfo) return [];
    return [{
      commonElem: {
        serviceType: 48,
        pbElem: new NapProtoMsg(MsgInfo).encode(this.msgInfo),
        businessType: 22,
      },
    }];
  }

  override toPreview (): string {
    return '[语音]';
  }
}

export class PacketMsgFileElement extends IPacketMsgElement<SendFileElement> {
  fileName: string;
  filePath: string;
  fileSize: number;
  fileSha1?: Uint8Array;
  fileMd5?: Uint8Array;
  fileUuid?: string;
  fileHash?: string;
  isGroupFile?: boolean;
  _private_send_uid?: string;
  _private_recv_uid?: string;
  _e37_800_rsp?: NapProtoEncodeStructType<typeof OidbSvcTrpcTcp0XE37_800Response>;

  constructor (element: SendFileElement) {
    super(element);
    this.fileName = element.fileElement.fileName;
    this.filePath = element.fileElement.filePath;
    this.fileSize = +element.fileElement.fileSize;
  }

  override get valid (): boolean {
    return this.isGroupFile || Boolean(this._e37_800_rsp);
  }

  override buildContent (): Uint8Array | undefined {
    if (this.isGroupFile || !this._e37_800_rsp) return undefined;
    return new NapProtoMsg(FileExtra).encode({
      file: {
        fileType: 0,
        fileUuid: this.fileUuid,
        fileMd5: this.fileMd5,
        fileName: this.fileName,
        fileSize: BigInt(this.fileSize),
        subcmd: 1,
        dangerEvel: 0,
        expireTime: Math.floor(Date.now() / 1000) + 7 * 24 * 60 * 60,
        fileHash: this.fileHash,
      },
      field6: {
        field2: {
          field1: this._e37_800_rsp?.body?.field30?.field110,
          fileUuid: this.fileUuid,
          fileName: this.fileName,
          field6: this._e37_800_rsp?.body?.field30?.field3,
          field7: this._e37_800_rsp?.body?.field30?.field101,
          field8: this._e37_800_rsp?.body?.field30?.field100,
          timestamp1: this._e37_800_rsp?.body?.field30?.timestamp1,
          fileHash: this.fileHash,
          selfUid: this._private_send_uid,
          destUid: this._private_recv_uid,
        },
      },
    });
  }

  override buildElement (): NapProtoEncodeStructType<typeof Elem>[] {
    if (!this.isGroupFile) return [];
    const lb = Buffer.alloc(2);
    const transElemVal = new NapProtoMsg(GroupFileExtra).encode({
      field1: 6,
      fileName: this.fileName,
      inner: {
        info: {
          busId: 102,
          fileId: this.fileUuid,
          fileSize: BigInt(this.fileSize),
          fileName: this.fileName,
          fileSha: this.fileSha1,
          extInfoString: '',
          fileMd5: this.fileMd5,
        },
      },
    });
    lb.writeUInt16BE(transElemVal.length);
    return [{
      transElem: {
        elemType: 24,
        elemValue: Buffer.concat([Buffer.from([0x01]), lb, transElemVal]), // TLV
      },
    }];
  }

  override toPreview (): string {
    return `[文件]${this.fileName}`;
  }
}

export class PacketMsgLightAppElement extends IPacketMsgElement<SendArkElement> {
  payload: string;

  constructor (element: SendArkElement) {
    super(element);
    this.payload = element.arkElement.bytesData;
  }

  override buildElement (): NapProtoEncodeStructType<typeof Elem>[] {
    return [{
      lightAppElem: {
        data: Buffer.concat([
          Buffer.from([0x01]),
          zlib.deflateSync(Buffer.from(this.payload, 'utf-8')),
        ]),
      },
    }];
  }

  override toPreview (): string {
    return '[卡片消息]';
  }
}

export class PacketMsgMarkDownElement extends IPacketMsgElement<SendMarkdownElement> {
  content: string;

  constructor (element: SendMarkdownElement) {
    super(element);
    this.content = element.markdownElement.content;
  }

  override buildElement (): NapProtoEncodeStructType<typeof Elem>[] {
    return [{
      commonElem: {
        serviceType: 45,
        pbElem: new NapProtoMsg(MarkdownData).encode({
          content: this.content,
        }),
        businessType: 1,
      },
    }];
  }

  override toPreview (): string {
    return `[Markdown消息 ${this.content}]`;
  }
}

export class PacketMultiMsgElement extends IPacketMsgElement<SendMultiForwardMsgElement> {
  resid: string;
  message: PacketMsg[];
  uuid: string;

  constructor (rawElement: SendMultiForwardMsgElement, message?: PacketMsg[]) {
    super(rawElement);
    this.resid = rawElement.multiForwardMsgElement.resId;
    this.message = message ?? [];
    this.uuid = rawElement.multiForwardMsgElement.fileName || crypto.randomUUID();
  }

  override buildElement (): NapProtoEncodeStructType<typeof Elem>[] {
    return [{
      lightAppElem: {
        data: Buffer.concat([
          Buffer.from([0x01]),
          zlib.deflateSync(Buffer.from(JSON.stringify(ForwardMsgBuilder.fromPacketMsg(this.resid, this.message, undefined, undefined, undefined, undefined, this.uuid)), 'utf-8')),
        ]),
      },
    }];
  }

  override toPreview (): string {
    return '[聊天记录]';
  }
}