import { access, mkdir, readFile, writeFile } from "node:fs/promises"
import path from "node:path"

async function safeRead(filePath) {
  try {
    return await readFile(filePath, "utf8")
  } catch {
    return null
  }
}

function nowIso() {
  return new Date().toISOString()
}

function envFlag(name, defaultValue = false) {
  const value = process.env[name]
  if (value === undefined) return defaultValue
  return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase())
}

async function resolveSyncCommand(directory) {
  const configured = process.env.AIW_MATTERMOST_SYNC_CMD?.trim()
  if (configured) return configured

  const fallbackScript = path.join(directory, "scripts/mattermost/sync.sh")
  try {
    await access(fallbackScript)
    return `bash "${fallbackScript}"`
  } catch {
    return ""
  }
}

async function resolveSyncContent(directory, stdoutText) {
  const cleaned = (stdoutText || "").trim()
  if (cleaned) return cleaned

  const generatedPath = path.join(directory, "scripts/mattermost/generated/mattermost_context.jsonl")
  const generated = await safeRead(generatedPath)
  return (generated || "").trim()
}

async function resolveProfileInbox(directory) {
  const profile = process.env.AIW_PROJECT_PROFILE?.trim() || "fidelity"
  const configured = process.env.AIW_PROJECT_INBOX_DIR?.trim()
  if (configured) return path.isAbsolute(configured) ? configured : path.join(directory, configured)

  const workspaceConfigPath = path.join(directory, "profiles", profile, "workspace.json")
  try {
    const config = JSON.parse(await readFile(workspaceConfigPath, "utf8"))
    const inboxDir = config?.inbox_dir || `workspaces/${profile}/inbox`
    return path.isAbsolute(inboxDir) ? inboxDir : path.join(directory, inboxDir)
  } catch {
    return path.join(directory, "workspaces", profile, "inbox")
  }
}

function extractPromptText(event) {
  const candidates = [
    event?.properties?.text,
    event?.properties?.message,
    event?.properties?.prompt,
    event?.text,
    event?.message,
    event?.prompt,
  ]

  for (const candidate of candidates) {
    if (typeof candidate === "string" && candidate.trim()) {
      return candidate
    }
  }

  try {
    return JSON.stringify(event)
  } catch {
    return ""
  }
}

function requiresFreshMattermost(promptText) {
  const text = promptText
    .normalize("NFD")
    .replace(/[\u0300-\u036f]/g, "")
    .toLowerCase()

  const freshnessPatterns = [
    /\bultimo(?:s|a|as)?\s+(?:mensaje|mensajes|respuesta|respuestas|update|updates)\b/,
    /\bmensaje(?:s)?\s+(?:mas\s+)?reciente(?:s)?\b/,
    /\bque\s+(?:dijo|menciono|respondio|contesto)\b/,
    /\b(?:dijo|menciono|respondio|contesto)\s+(?:jeff|manager|supervisor)\b/,
    /\b(?:latest|last|recent)\s+(?:message|messages|reply|replies|update|updates)\b/,
    /\bwhat\s+did\s+.+\s+(?:say|mention|reply)\b/,
    /\b(?:said|mentioned|replied)\s+(?:jeff|manager|supervisor)\b/,
    /\b(?:sync|refresh|sincroniza|actualiza)\s+(?:mattermost|mensajes|messages|inbox)\b/,
    /\b(?:revisa|check|look\s+at)\s+(?:mattermost|mensajes|messages|inbox)\b/,
  ]

  const mattermostTerms = [
    "mattermost",
    "mensaje",
    "mensajes",
    "message",
    "messages",
    "manager",
    "stakeholder",
    "supervisor",
    "lead",
    "inbox",
  ]

  const configuredTerms = [
    process.env.AIW_COMMUNICATION_FRESH_TERMS,
    process.env.AIW_MANAGER_NAME,
    process.env.AIW_PRIMARY_STAKEHOLDER,
    "jeff",
    "fidelity-preguntas",
  ]
    .filter(Boolean)
    .flatMap((value) => String(value).split(","))
    .map((value) => value.trim().toLowerCase())
    .filter(Boolean)

  const sourceTerms = [
    ...mattermostTerms,
    ...configuredTerms,
  ]

  return freshnessPatterns.some((pattern) => pattern.test(text)) &&
    sourceTerms.some((term) => text.includes(term))
}

export const MattermostInbox = async ({ $, directory, client }) => {
  let lastSyncAt = 0

  async function writeStatus(statusPath, data) {
    await mkdir(path.dirname(statusPath), { recursive: true })
    await writeFile(statusPath, `${JSON.stringify(data, null, 2)}\n`, "utf8")
  }

  async function sync(reason, options = {}) {
    const command = await resolveSyncCommand(directory)
    if (!command) return

    const intervalMinutes = Number.parseInt(
      process.env.AIW_MATTERMOST_SYNC_INTERVAL_MINUTES ||
        "15",
      10,
    )
    const minIntervalMs = Math.max(1, Number.isNaN(intervalMinutes) ? 15 : intervalMinutes) * 60 * 1000
    const now = Date.now()

    if (!options.force && now - lastSyncAt < minIntervalMs) return
    lastSyncAt = now
    const syncStartedAt = Date.now()

    const inboxDir = await resolveProfileInbox(directory)
    const latestPath = path.join(inboxDir, "mattermost-latest.md")
    const statusPath = path.join(inboxDir, "mattermost-status.json")

    const commandSource = process.env.AIW_MATTERMOST_SYNC_CMD?.trim()
      ? "aiw-env"
      : "workspace-default"

    try {
      await mkdir(inboxDir, { recursive: true })
      const stdoutText = await $`bash -lc ${command}`.text()
      const output = await resolveSyncContent(directory, stdoutText)
      const previous = await safeRead(latestPath)

      if (output) {
        if (previous !== `${output}\n` && previous !== output) {
          const stamp = nowIso().replace(/[:]/g, "-")
          const snapshotPath = path.join(inboxDir, `mattermost-${stamp}.md`)
          await writeFile(latestPath, `${output}\n`, "utf8")
          await writeFile(snapshotPath, `${output}\n`, "utf8")
        }

        await writeStatus(statusPath, {
          syncedAt: nowIso(),
          durationMs: Date.now() - syncStartedAt,
          reason,
          forced: Boolean(options.force),
          changed: previous !== `${output}\n` && previous !== output,
          commandConfigured: true,
          commandSource,
        })
      } else {
        await writeStatus(statusPath, {
          syncedAt: nowIso(),
          durationMs: Date.now() - syncStartedAt,
          reason,
          forced: Boolean(options.force),
          changed: false,
          commandConfigured: true,
          commandSource,
          note: "Sync command returned no output.",
        })
      }
    } catch (error) {
      await writeStatus(statusPath, {
        syncedAt: nowIso(),
        durationMs: Date.now() - syncStartedAt,
        reason,
        forced: Boolean(options.force),
        changed: false,
        commandConfigured: true,
        commandSource,
        error: error instanceof Error ? error.message : String(error),
      })

      await client.app.log({
        body: {
          service: "mattermost-inbox",
          level: "warn",
          message: "Mattermost sync failed",
          extra: {
            reason,
            error: error instanceof Error ? error.message : String(error),
          },
        },
      })
    }
  }

  return {
    event: async ({ event }) => {
      if (
        event.type === "session.created" &&
        envFlag("AIW_MATTERMOST_SYNC_ON_SESSION", false)
      ) {
        await sync("session.created")
      }

      if (event.type === "tui.prompt.append") {
        const promptText = extractPromptText(event)
        const forceFreshMattermost = requiresFreshMattermost(promptText)
        const allowPromptSync = envFlag("AIW_MATTERMOST_SYNC_ON_PROMPT", false)

        if (!forceFreshMattermost && !allowPromptSync) return

        await sync(
          forceFreshMattermost
            ? "tui.prompt.append:fresh-mattermost-request"
            : "tui.prompt.append",
          { force: forceFreshMattermost },
        )
      }
    },
  }
}