// ✅ OTel SDK initialisation — must run before any other imports
// file: src/telemetry/otel.ts

import { NodeSDK } from '@opentelemetry/sdk-node'
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-grpc'
import { Resource } from '@opentelemetry/resources'
import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions'
import { SimpleSpanProcessor } from '@opentelemetry/sdk-trace-node'

const sdk = new NodeSDK({
  resource: new Resource({
    [SemanticResourceAttributes.SERVICE_NAME]: 'workspace-ai-gateway',
    [SemanticResourceAttributes.SERVICE_VERSION]: process.env.APP_VERSION ?? '0.0.0',
    [SemanticResourceAttributes.DEPLOYMENT_ENVIRONMENT]: process.env.NODE_ENV,
  }),
  spanProcessors: [
    new SimpleSpanProcessor(
      new OTLPTraceExporter({
        url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? 'http://localhost:4317',
      }),
    ),
  ],
})

sdk.start()
process.on('SIGTERM', () => sdk.shutdown())

export { sdk }

// ✅ Instrumented LLM streaming call with GenAI semantic conventions
// file: src/telemetry/InstrumentedLlmCall.ts

import { trace, SpanStatusCode, SpanKind } from '@opentelemetry/api'

const tracer = trace.getTracer('workspace-ai-gateway', '1.0.0')

export async function* instrumentedStreamCall(
  orgId: string,
  model: string,
  inputTokens: number,
  callFn: () => AsyncGenerator<WorkspaceAction>,
): AsyncGenerator<WorkspaceAction> {
  const span = tracer.startSpan('gen_ai.chat', {
    kind: SpanKind.CLIENT,
    attributes: {
      // gen_ai.provider.name replaces deprecated gen_ai.system (OTel GenAI conventions v0.9+)
      'gen_ai.provider.name': model.startsWith('claude') ? 'anthropic' : 'openai',
      'gen_ai.operation.name': 'chat',
      'gen_ai.request.model': model,
      'gen_ai.usage.input_tokens': inputTokens,
      'gen_ai.workspace.org_id': orgId,
    },
  })

  const requestSentAt = performance.now()
  let firstTokenAt: number | null = null
  let outputTokenCount = 0
  let prevTokenAt = requestSentAt
  const itlSamples: number[] = []

  try {
    for await (const action of callFn()) {
      const now = performance.now()

      if (firstTokenAt === null) {
        firstTokenAt = now
        span.setAttribute('gen_ai.workspace.ttft_ms', Math.round(now - requestSentAt))
      } else {
        itlSamples.push(now - prevTokenAt)
      }

      prevTokenAt = now
      outputTokenCount++
      yield action
    }

    // Emit final metrics as span attributes
    span.setAttributes({
      'gen_ai.usage.output_tokens': outputTokenCount,
      'gen_ai.workspace.p50_itl_ms': percentile(itlSamples, 50),
      'gen_ai.workspace.p99_itl_ms': percentile(itlSamples, 99),
      'gen_ai.workspace.total_ms': Math.round(performance.now() - requestSentAt),
      'gen_ai.response.finish_reason': 'end_turn',
    })

    span.setStatus({ code: SpanStatusCode.OK })
  } catch (error) {
    span.recordException(error as Error)
    span.setStatus({ code: SpanStatusCode.ERROR, message: (error as Error).message })
    throw error
  } finally {
    span.end()
  }
}

function percentile(values: number[], p: number): number {
  if (values.length === 0) return 0
  const sorted = [...values].sort((a, b) => a - b)
  const idx = Math.floor((p / 100) * sorted.length)
  return Math.round(sorted[Math.min(idx, sorted.length - 1)])
}

// ✅ Retrieval pipeline span — wraps hybrid search + reranking
// file: src/telemetry/InstrumentedRetrieval.ts

import { trace, SpanStatusCode, SpanKind } from '@opentelemetry/api'

const tracer = trace.getTracer('workspace-ai-gateway')

export async function instrumentedRetrieve(
  orgId: string,
  query: string,
  retrieveFn: () => Promise<RankedResult[]>,
): Promise<RankedResult[]> {
  return tracer.startActiveSpan('workspace.rag.retrieve', {
    kind: SpanKind.INTERNAL,
    attributes: {
      'workspace.retrieval.org_id': orgId,
      'workspace.retrieval.query_length': query.length,
    },
  }, async (span) => {
    const hybridStart = performance.now()

    try {
      const results = await retrieveFn()

      span.setAttributes({
        'workspace.retrieval.hybrid_search_ms': Math.round(performance.now() - hybridStart),
        'workspace.retrieval.chunks_returned': results.length,
        'workspace.retrieval.top_score': results[0]?.rerankerScore?.toFixed(3) ?? '0',
        'workspace.retrieval.total_tokens': results.reduce((s, r) => s + r.tokenCount, 0),
      })

      span.setStatus({ code: SpanStatusCode.OK })
      return results
    } catch (error) {
      span.recordException(error as Error)
      span.setStatus({ code: SpanStatusCode.ERROR })
      throw error
    } finally {
      span.end()
    }
  })
}

// ✅ Client-side TTFT span — exported to OTel collector via OTLP/HTTP
// file: apps/web/src/telemetry/ClientTtftSpan.ts

import { WebTracerProvider } from '@opentelemetry/sdk-trace-web'
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http'
import { trace } from '@opentelemetry/api'

const provider = new WebTracerProvider()
provider.addSpanProcessor(
  new SimpleSpanProcessor(
    new OTLPTraceExporter({ url: '/api/otel/traces' })
  )
)
provider.register()

const webTracer = trace.getTracer('workspace-web-client', '1.0.0')

export function measureClientTtft(
  parentTraceId: string,  // From SSE response header X-Trace-Id
): { markFirstToken: () => void } {
  const requestSentAt = performance.now()

  const span = webTracer.startSpan('client.sse.ttft', {
    attributes: {
      'gen_ai.workspace.server_trace_id': parentTraceId,
      'gen_ai.workspace.client_ua': navigator.userAgent.slice(0, 100),
    },
  })

  return {
    markFirstToken: () => {
      span.setAttribute('gen_ai.workspace.client_ttft_ms', Math.round(performance.now() - requestSentAt))
      span.end()
    },
  }
}