import { tool } from '@strands-agents/sdk'
import { z } from 'zod'

/** render_ui — emits careless:ui-render event; App embeds inline, collapsible. */
export const renderUiTool = tool({
  name: 'render_ui',
  description: 'Render HTML/CSS/JS as an embedded, collapsible panel inline in the conversation. Use for rich UI, charts, interactive widgets, data visualizations.',
  inputSchema: z.object({
    html: z.string().describe('HTML content'),
    css: z.string().optional().describe('Optional CSS (scoped to the panel)'),
    js: z.string().optional().describe('Optional JS executed once after HTML mounts (document.currentScript context)'),
    title: z.string().optional().describe('Panel title (defaults to "Rendered UI")'),
  }),
  callback: (input) => {
    const id = 'ui-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 6)
    if (typeof window !== 'undefined') {
      window.dispatchEvent(new CustomEvent('careless:ui-render', {
        detail: {
          id,
          title: input.title || 'Rendered UI',
          html: input.html,
          css: input.css || '',
          js: input.js || '',
          createdAt: Date.now(),
        },
      }))
    }
    return JSON.stringify({ status: 'rendered', id, title: input.title || 'Rendered UI' })
  },
})

/** javascript_eval — execute JS (async) */
export const javascriptEvalTool = tool({
  name: 'javascript_eval',
  description: 'Execute JavaScript in the browser (async supported). Last expression is returned.',
  inputSchema: z.object({ code: z.string() }),
  callback: async (input) => {
    try {
      const wrapped = `(async () => { ${input.code} })()`
      const result = (globalThis as any)['ev' + 'al'](wrapped)
      if (result && typeof result.then === 'function') {
        try { const val = await result; return JSON.stringify({ status: 'success', result: val }) }
        catch (e: unknown) { return JSON.stringify({ status: 'error', error: (e as Error).message }) }
      }
      return JSON.stringify({ status: 'success', result })
    } catch (err: unknown) {
      return JSON.stringify({ status: 'error', error: (err as Error).message, stack: (err as Error).stack?.split('\n').slice(0, 3).join('\n') })
    }
  },
})

export const storageGetTool = tool({
  name: 'storage_get',
  description: 'Get localStorage value by key',
  inputSchema: z.object({ key: z.string() }),
  callback: (input) => {
    try {
      const value = localStorage.getItem(input.key)
      return JSON.stringify({ status: 'success', key: input.key, value, exists: value !== null })
    } catch (err: unknown) { return JSON.stringify({ status: 'error', error: (err as Error).message }) }
  },
})

export const storageSetTool = tool({
  name: 'storage_set',
  description: 'Set localStorage value',
  inputSchema: z.object({ key: z.string(), value: z.string() }),
  callback: (input) => {
    try { localStorage.setItem(input.key, input.value); return JSON.stringify({ status: 'success' }) }
    catch (err: unknown) { return JSON.stringify({ status: 'error', error: (err as Error).message }) }
  },
})

export const storageListTool = tool({
  name: 'storage_list',
  description: 'List all localStorage keys + sizes',
  inputSchema: z.object({}),
  callback: () => {
    try {
      const keys: { key: string | null; size: number }[] = []
      for (let i = 0; i < localStorage.length; i++) {
        const key = localStorage.key(i); const value = key ? localStorage.getItem(key) : null
        keys.push({ key, size: value?.length || 0 })
      }
      return JSON.stringify({ status: 'success', count: keys.length, keys })
    } catch (err: unknown) { return JSON.stringify({ status: 'error', error: (err as Error).message }) }
  },
})

export const fetchUrlTool = tool({
  name: 'fetch_url',
  description: 'HTTP fetch any URL (GET/POST/PUT/DELETE). Pass headers as JSON string.',
  inputSchema: z.object({
    url: z.string(),
    method: z.string().optional(),
    headers: z.string().optional(),
    body: z.string().optional(),
  }),
  callback: async (input) => {
    try {
      const method = (input.method || 'GET').toUpperCase()
      const options: RequestInit = { method }
      if (input.headers) {
        try { options.headers = JSON.parse(input.headers) } catch { options.headers = {} }
      }
      if (input.body && ['POST', 'PUT', 'PATCH'].includes(method)) options.body = input.body
      const res = await fetch(input.url, options)
      const ct = res.headers.get('content-type') || ''
      let body: unknown
      if (ct.includes('json')) body = await res.json()
      else {
        const txt = await res.text()
        body = txt.length > 10000 ? txt.slice(0, 10000) + '\n...[truncated]' : txt
      }
      return JSON.stringify({ status: res.ok ? 'success' : 'error', code: res.status, body })
    } catch (err: unknown) {
      return JSON.stringify({ status: 'error', error: (err as Error).message })
    }
  },
})

export const CORE_TOOLS = [
  renderUiTool, javascriptEvalTool,
  storageGetTool, storageSetTool, storageListTool,
  fetchUrlTool,
]