// @ts-ignore
const { PicGo } = require('picgo')

const picgo = new PicGo()

import { PicGo } from 'picgo'

const picgo = new PicGo()

// 配置上传插件
picgo.setConfig({
  'picGo-BED': 'github',
  'picGo-GitHub-token': 'your-token',
  'picGo-GitHub-repo': 'username/repo'
})

// 上传指定文件
const files = ['/path/to/image1.jpg', '/path/to/image2.png']
const result = await picgo.upload(files)

console.log(result.output) // 返回的图片 URL 数组

/**
 * PicGo 工具封装（TypeScript）
 * 依赖：picgo (v1.5.0+)
 * 用法示例：
 *   import { upload } from '@/utils/picgo'
 *   await upload(['/path/to/img.jpg']) // 上传指定文件
 *   await upload() // 上传剪贴板第一张图片
 */

// 使用 require 以兼容 picgo 的 CommonJS 导出
// @ts-ignore
const { PicGo } = require('picgo')

type UploadResult = any

/**
 * 上传图片（支持传入文件路径数组，或不传则上传剪贴板第一张图片）
 * @param paths 可选的本地文件路径数组
 */
export async function upload(paths?: string[]): Promise<UploadResult> {
  const picgo = new PicGo()

  return new Promise((resolve, reject) => {
    const onUpload = (ctx: any) => {
      // PicGo 在上传完成会触发 'upload' 事件，回调中包含 ctx
      cleanup()
      resolve(ctx)
    }

    const onFailed = (ctx: any) => {
      cleanup()
      reject(ctx)
    }

    const onError = (err: any) => {
      cleanup()
      reject(err)
    }

    function cleanup() {
      try {
        picgo.removeListener && picgo.removeListener('upload', onUpload)
        picgo.removeListener && picgo.removeListener('failed', onFailed)
        picgo.removeListener && picgo.removeListener('error', onError)
      } catch (e) {
        // ignore
      }
    }

    // 绑定事件
    try {
      picgo.on && picgo.on('upload', onUpload)
      picgo.on && picgo.on('failed', onFailed)
      picgo.on && picgo.on('error', onError)

      // 触发上传：传入数组则按路径上传；不传则尝试上传剪贴板里的第一张图片
      if (Array.isArray(paths) && paths.length > 0) {
        picgo.upload(paths)
      } else {
        picgo.upload()
      }
    } catch (err) {
      cleanup()
      reject(err)
    }
  })
}

export default { upload }

// 不传参数，自动上传剪贴板中的第一张图片
const result = await picgo.upload()

const files = [
  '/path/to/image1.jpg',
  '/path/to/image2.png',
  '/path/to/image3.webp'
]

const result = await picgo.upload(files)
// result.output 包含所有上传成功的图片 URL
console.log(result.output)
// [
//   'https://example.com/image1.jpg',
//   'https://example.com/image2.png',
//   'https://example.com/image3.webp'
// ]

picgo.on('upload', (ctx: any) => {
  console.log('上传成功！', ctx.output)
})

picgo.on('failed', (ctx: any) => {
  console.error('上传失败！', ctx.output)
})

picgo.on('error', (err: any) => {
  console.error('发生错误！', err)
})

import * as vscode from 'vscode'
// @ts-ignore
const { PicGo } = require('picgo')

export function activate(context: vscode.ExtensionContext) {
  const picgo = new PicGo()
  
  context.subscriptions.push(vscode.commands.registerCommand(
    'my-extension.uploadImage',
    async () => {
      const editor = vscode.window.activeTextEditor
      if (!editor) return
      
      const selection = editor.selection
      const text = editor.document.getText(selection)
      
      // 处理粘贴的图片
      const result = await picgo.upload()
      const urls = result.output as string[]
      
      // 插入 Markdown 链接
      urls.forEach(url => {
        editor.edit(editBuilder => {
          editBuilder.insert(selection.start, `![image](${url})`)
        })
      })
    }
  ))
}

class PasteUploader {
  private picgo: PicGo
  
  constructor() {
    this.picgo = new PicGo()
    this.configure()
    this.bindEvents()
  }
  
  private configure() {
    this.picgo.setConfig({
      'picGo-BED': 'github',
      'picGo-GitHub-token': process.env.GITHUB_TOKEN!,
      'picGo-GitHub-repo': 'username/repo'
    })
  }
  
  private bindEvents() {
    // 监听粘贴事件
    document.addEventListener('paste', async (event: ClipboardEvent) => {
      const items = event.clipboardData?.items
      if (!items) return
      
      for (const item of items) {
        if (item.type.startsWith('image/')) {
          const blob = item.getAsFile()
          if (blob) {
            const url = await this.uploadBlob(blob)
            this.insertAtCursor(`![image](${url})`)
          }
        }
      }
    })
  }
  
  private async uploadBlob(blob: Blob): Promise<string> {
    // 将 Blob 转为临时文件
    const tempPath = await this.saveToTemp(blob)
    // 调用 PicGo 上传
    const result = await this.picgo.upload([tempPath])
    return (result.output as string[])[0]
  }
}

const { PicGo } = require('picgo')

const picgo = new PicGo()

// 注册自定义上传插件
picgo.registerUploadPlugin('custom-bed', class CustomUpload {
  constructor (ctx) {
    this.ctx = ctx
  }
  
  async upload (fileArray) {
    // fileArray 格式：
    // [
    //   {
    //     url: 'file:///path/to/image.jpg',
    //     base64Address: 'data:image/jpeg;base64,...',
    //     isImage: true
    //   }
    // ]
    
    const results = await Promise.all(
      fileArray.map(async (file) => {
        // 自定义上传逻辑
        const url = await this.uploadToCustomServer(file)
        return {
          url,
          base64Address: file.base64Address,
          isImage: true
        }
      })
    )
    
    return results
  }
  
  async uploadToCustomServer (file) {
    // 你的自定义上传逻辑
    return 'https://your-server.com/uploaded-image.jpg'
  }
})

// 使用自定义平台
picgo.setConfig('picGo-BED', 'custom-bed')

import axios from 'axios'

interface GitHubConfig {
  token: string
  owner: string
  repo: string
  branch: string
  uploadPath: string
  customDomain?: string
}

interface ImageItem {
  id: string
  url: string
  name: string
  size: number
  uploadDate: string
}

/**
 * 上传文件到 GitHub Repository
 */
export async function uploadToGitHub(
  config: GitHubConfig,
  file: File,
  progress?: (percent: number) => void
): Promise<ImageItem> {
  // 生成文件名：年月日时分秒 + 3 位随机数
  const now = new Date()
  const pad = (n: number, len = 2) => n.toString().padStart(len, '0')
  const fileName = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}${Math.floor(Math.random() * 900) + 100}${getFileExtension(file.name)}`

  const normalizedPath = (config.uploadPath || '').replace(/^\/+|\/+$/g, '')
  const path = normalizedPath ? `${normalizedPath}/${fileName}` : fileName

  const base64 = await fileToBase64(file)

  try {
    await axios.put(
      `https://api.github.com/repos/${config.owner}/${config.repo}/contents/${encodeURIComponent(path)}`,
      {
        message: `Upload image: ${file.name}`,
        content: base64,
        branch: config.branch
      },
      {
        headers: {
          Authorization: `Bearer ${config.token}`,
          'Content-Type': 'application/json'
        },
        onUploadProgress: (e) => {
          if (progress && e.total) {
            progress(Math.round((e.loaded * 100) / e.total))
          }
        }
      }
    )

    const imageUrl = config.customDomain
      ? `${config.customDomain}/${path}`
      : `https://raw.githubusercontent.com/${config.owner}/${config.repo}/${config.branch}/${path}`

    return {
      id: Date.now().toString(),
      url: imageUrl,
      name: file.name,
      size: file.size,
      uploadDate: new Date().toISOString()
    }
  } catch (err: any) {
    if (err?.message === 'Network Error' || err?.code === 'ERR_NETWORK') {
      throw new Error('Network Error: 无法连接到 GitHub API')
    }
    if (err?.response) {
      throw new Error(`Upload failed: ${err.response.status} ${err.response.data?.message}`)
    }
    throw err
  }
}

async function uploadToMultiplePlatforms(files: string[], platforms: string[]) {
  const results: Record<string, string[]> = {}
  
  for (const platform of platforms) {
    try {
      const picgo = new PicGo()
      
      // 配置不同平台
      switch (platform) {
        case 'github':
          picgo.setConfig({
            'picGo-BED': 'github',
            'picGo-GitHub-token': process.env.GITHUB_TOKEN!,
            'picGo-GitHub-repo': 'username/repo'
          })
          break
        case 'aliyun':
          picgo.setConfig({
            'picGo-BED': 'upstream-aliyun-oss',
            'picGo-Aliyun-OSS-bucket': 'my-bucket',
            'picGo-Aliyun-OSS-region': 'oss-cn-shanghai'
          })
          break
      }
      
      const result = await picgo.upload(files)
      results[platform] = result.output as string[]
    } catch (err) {
      console.error(`Platform ${platform} upload failed:`, err)
      results[platform] = []
    }
  }
  
  return results
}

// 使用 require 以兼容 picgo 的 CommonJS 导出
// @ts-ignore
const { PicGo } = require('picgo')

export async function upload(paths?: string[]): Promise<UploadResult> {
  const picgo = new PicGo()

  return new Promise((resolve, reject) => {
    const onUpload = (ctx: any) => {
      cleanup()
      resolve(ctx)
    }

    const onFailed = (ctx: any) => {
      cleanup()
      reject(ctx)
    }

    const onError = (err: any) => {
      cleanup()
      reject(err)
    }

    function cleanup() {
      try {
        picgo.removeListener && picgo.removeListener('upload', onUpload)
        picgo.removeListener && picgo.removeListener('failed', onFailed)
        picgo.removeListener && picgo.removeListener('error', onError)
      } catch (e) {
        // ignore
      }
    }

    try {
      picgo.on && picgo.on('upload', onUpload)
      picgo.on && picgo.on('failed', onFailed)
      picgo.on && picgo.on('error', onError)

      if (Array.isArray(paths) && paths.length > 0) {
        picgo.upload(paths)
      } else {
        picgo.upload()
      }
    } catch (err) {
      cleanup()
      reject(err)
    }
  })
}

export async function uploadToGitHub(
  config: GitHubConfig,
  file: File,
  progress?: (percent: number) => void
): Promise<ImageItem> {
  // 生成唯一文件名
  const fileName = generateUniqueFileName(file.name)
  const path = `${config.uploadPath}/${fileName}`
  
  const base64 = await fileToBase64(file)

  await api.put(
    `/repos/${config.owner}/${config.repo}/contents/${encodeURIComponent(path)}`,
    {
      message: `Upload image: ${file.name}`,
      content: base64,
      branch: config.branch
    },
    {
      headers: {
        Authorization: `Bearer ${config.token}`,
        'Content-Type': 'application/json'
      },
      onUploadProgress: (e) => {
        if (progress && e.total) {
          progress(Math.round((e.loaded * 100) / e.total))
        }
      }
    }
  )

  const imageUrl = config.customDomain
    ? `${config.customDomain}/${path}`
    : `https://raw.githubusercontent.com/${config.owner}/${config.repo}/${config.branch}/${path}`

  return {
    id: Date.now().toString(),
    url: imageUrl,
    name: file.name,
    size: file.size,
    uploadDate: new Date().toISOString()
  }
}

export function generateLink(
  image: ImageItem,
  format: string,
  customPattern?: string
): string {
  const url = image.url
  switch (format) {
    case 'markdown':
      return `![${image.name}](${url})`
    case 'html':
      return `<img src="${url}" alt="${image.name}" />`
    case 'url':
      return url
    case 'ubb':
      return `[img]${url}[/img]`
    case 'custom':
      return customPattern
        ?.replace('{url}', url)
        .replace('{name}', image.name) || url
    default:
      return `![${image.name}](${url})`
  }
}

try {
  const result = await picgo.upload(files)
  console.log('上传成功:', result.output)
} catch (err) {
  if (err.code === 'PLUGIN_UPLOAD_ERROR') {
    // 上传插件错误
    console.error('上传失败:', err.message)
  } else if (err.code === 'CONFIG_NOT_FOUND') {
    // 配置缺失
    console.error('请检查 PicGo 配置')
  } else {
    // 其他错误
    console.error('未知错误:', err)
  }
}

// 推荐：复用实例
const picgo = new PicGo()
// 多次调用 upload
await picgo.upload(files1)
await picgo.upload(files2)

picgo.registerTransformPlugin('compress', class Compress {
  async transform (file) {
    // 使用 sharp 或其他库压缩图片
    return compressedBuffer
  }
})

const token = process.env.GITHUB_TOKEN
if (!token) {
  throw new Error('GITHUB_TOKEN not set')
}