Avtex/app/server/utils/giteaApi.ts

// Gitea API integration for XFlow canvas sync
// Structure:
//   Personal canvases → AVTEX/user-{username}  (created on first save)
//   Group canvases    → AVTEX/group-{groupId}   (created on group creation)
//   Public canvases   → AVTEX/MMAVTEX           (shared org repo)

interface GiteaFile {
  content: string   // base64
  sha?: string
}

const getConfig = () => {
  const config = useRuntimeConfig()
  return {
    url: config.giteaUrl,
    token: config.giteaToken,
    org: config.giteaOrg,
    mindmapRepo: config.giteaMindmapRepo,
    projectRepo: config.giteaProjectRepo,
  }
}

const apiHeaders = (token: string) => ({
  'Authorization': `token ${token}`,
  'Content-Type': 'application/json',
  'Accept': 'application/json'
})

// Resolve which repo to use based on canvas ownership
export function resolveRepo(opts: { username?: string; groupId?: string; isPublic?: boolean }): string {
  const { org, mindmapRepo } = getConfig()
  if (opts.groupId) return `group-${opts.groupId}`
  if (opts.username && !opts.isPublic) return `user-${opts.username}`
  return mindmapRepo
}

// Ensure repository exists in org, create if not
export async function ensureRepo(repoName: string, description = ''): Promise<boolean> {
  const { url, token, org } = getConfig()
  const h = apiHeaders(token)

  // Check if exists
  try {
    await $fetch(`${url}/api/v1/repos/${org}/${repoName}`, { headers: h })
    return true
  } catch { }

  // Create
  try {
    await $fetch(`${url}/api/v1/orgs/${org}/repos`, {
      method: 'POST',
      headers: h,
      body: {
        name: repoName,
        description: description || `XFlow canvas repo: ${repoName}`,
        private: !repoName.startsWith('group-') && repoName !== getConfig().mindmapRepo,
        auto_init: true,
        default_branch: 'main'
      }
    })
    return true
  } catch (e) {
    console.error(`Gitea ensureRepo(${repoName}) error:`, e)
    return false
  }
}

// Get file from Gitea (returns null if not found)
export async function giteaGetFile(path: string, repo?: string): Promise<GiteaFile | null> {
  const { url, token, org, mindmapRepo } = getConfig()
  const repoName = repo || mindmapRepo
  try {
    const res = await $fetch<any>(`${url}/api/v1/repos/${org}/${repoName}/contents/${path}`, {
      headers: apiHeaders(token)
    })
    return { content: res.content, sha: res.sha }
  } catch {
    return null
  }
}

// Create or update file in Gitea
export async function giteaPutFile(path: string, content: string, message: string, sha?: string, repo?: string): Promise<boolean> {
  const { url, token, org, mindmapRepo } = getConfig()
  const repoName = repo || mindmapRepo
  const encoded = Buffer.from(content).toString('base64')

  try {
    await $fetch(`${url}/api/v1/repos/${org}/${repoName}/contents/${path}`, {
      method: sha ? 'PUT' : 'POST',
      headers: apiHeaders(token),
      body: {
        message,
        content: encoded,
        ...(sha ? { sha } : {})
      }
    })
    return true
  } catch (e) {
    console.error('Gitea putFile error:', e)
    return false
  }
}

// Save canvas to correct repo based on ownership
export async function saveCanvasToGitea(
  canvasId: string,
  canvasData: any,
  opts: { username?: string; groupId?: string; isPublic?: boolean } = {},
  commitMessage?: string
): Promise<boolean> {
  const repo = resolveRepo(opts)
  const path = `${canvasId}.canvas`
  const content = JSON.stringify(canvasData, null, 2)
  const message = commitMessage || `Update ${canvasId} at ${new Date().toLocaleString('ru-RU')}`

  await ensureRepo(repo)
  const existing = await giteaGetFile(path, repo)
  return giteaPutFile(path, content, message, existing?.sha, repo)
}

// Load canvas from Gitea
export async function loadCanvasFromGitea(
  canvasId: string,
  opts: { username?: string; groupId?: string; isPublic?: boolean } = {}
): Promise<any | null> {
  const repo = resolveRepo(opts)
  const file = await giteaGetFile(`${canvasId}.canvas`, repo)
  if (!file) return null

  try {
    return JSON.parse(Buffer.from(file.content, 'base64').toString('utf-8'))
  } catch {
    return null
  }
}

// List canvases in a repo
export async function listCanvasesFromGitea(repo?: string): Promise<string[]> {
  const { url, token, org, mindmapRepo } = getConfig()
  const repoName = repo || mindmapRepo
  try {
    const res = await $fetch<any[]>(`${url}/api/v1/repos/${org}/${repoName}/contents/`, {
      headers: apiHeaders(token)
    })
    return res
      .filter((f: any) => f.name.endsWith('.canvas'))
      .map((f: any) => f.name.replace('.canvas', ''))
  } catch {
    return []
  }
}