import {
  Queryable,
  QueryableHandler,
  studioMiddleware,
} from "queryable-object";
import { withMcp } from "with-mcp";
import { UserContext, withSimplerAuth } from "simplerauth-client";
import { Parallel } from "parallel-web";

interface Env {
  MCP_URL: string; // Reddit MCP server endpoint
  PARALLEL_API_KEY: string; // Parallel AI service authentication
  PARALLEL_WEBHOOK_SECRET: string; // Webhook signature verification
  COMPETITOR_ANALYSIS_DO: DurableObjectNamespace;
}

interface AnalysisRow {
  hostname: string;
  company_domain: string;
  company_name: string;
  status: "pending" | "done";
  username: string;
  profile_image_url: string;
  created_at: string;
  updated_at: string;
  visits: number;
  result: string | null; // JSON string of structured analysis
  error: string | null;
  // Enhanced search fields extracted from analysis
  category: string | null;
  business_description: string | null;
  industry_sector: string | null;
  keywords: string | null;
}

@Queryable()
export class CompetitorAnalysisDO extends DurableObject<Env> {
  sql: SqlStorage;

  constructor(state: DurableObjectState, env: Env) {
    super(state, env);
    this.sql = state.storage.sql;
  }

  async createAnalysis(analysis: AnalysisRow): Promise<void> {
    // Check for existing recent analysis
    const results = this.sql.exec(
      "SELECT * FROM analyses WHERE hostname = ? ORDER BY updated_at DESC LIMIT 1",
      analysis.hostname
    );
    const existing = results.toArray()[0] as AnalysisRow | undefined;

    if (existing?.status === "done") {
      // Add your daysBetween logic here if needed
      const daysDiff = daysBetween(new Date(existing.updated_at), new Date());
      if (daysDiff < 14) {
        throw new Error("Recent analysis exists");
      }
    }

    this.sql.exec(
      `INSERT OR REPLACE INTO analyses (hostname, company_domain, company_name, status, username, profile_image_url, created_at, updated_at, visits, result, error, category, business_description, industry_sector, keywords)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
      analysis.hostname,
      analysis.company_domain,
      analysis.company_name,
      analysis.status,
      analysis.username,
      analysis.profile_image_url,
      analysis.created_at,
      analysis.updated_at,
      analysis.visits || 0,
      analysis.result,
      analysis.error,
      analysis.category,
      analysis.business_description,
      analysis.industry_sector,
      analysis.keywords
    );
  }

  async searchAnalyses(query: string): Promise<AnalysisRow[]> {
    const lowerQuery = query.toLowerCase();
    const results = this.sql.exec(
      `SELECT * FROM analyses 
       WHERE LOWER(company_name) LIKE ?
          OR LOWER(business_description) LIKE ?
          OR LOWER(keywords) LIKE ?
       ORDER BY visits DESC, created_at DESC 
       LIMIT 20`,
      `%${lowerQuery}%`,
      `%${lowerQuery}%`,
      `%${lowerQuery}%`
    );
    return results.toArray() as AnalysisRow[];
  }
}

const performAnalysis = async (
  env: Env,
  do_stub: DurableObjectStub<CompetitorAnalysisDO>,
  context: {
    hostname: string;
    isDeep: boolean;
    url: URL;
    username: string;
    profile_image_url: string;
  }
) => {
  const { hostname, isDeep, url, username, profile_image_url } = context;
  const parallel = new Parallel({ apiKey: env.PARALLEL_API_KEY });

  const companyName = getCompanyName(hostname);
  const taskRun = await parallel.beta.taskRun.create(
    {
      input: `Conduct comprehensive competitive intelligence analysis for company: ${hostname} including a Reddit sentiment analysis`,
      processor: "ultra8x",
      metadata: { hostname, isDeep, username, profile_image_url },
      mcp_servers: [{ name: "Reddit", url: env.MCP_URL, type: "url" }],
      webhook: {
        url: `${url.protocol}//${url.host}/webhook`,
        event_types: ["task_run.status"],
      },
      task_spec: { output_schema: { type: "json", json_schema } },
    },
    {
      headers: {
        "parallel-beta": "mcp-server-2025-07-17,webhook-2025-08-12",
      },
    }
  );

  await do_stub.createAnalysis({
    hostname,
    company_domain: hostname,
    company_name: companyName,
    status: "pending",
    username: username || "",
    profile_image_url: profile_image_url || "",
    created_at: new Date().toISOString(),
    updated_at: new Date().toISOString(),
    visits: 0,
    result: null,
    error: null,
    category: null,
    business_description: null,
    industry_sector: null,
    keywords: null,
  });
};

const webhookId = request.headers.get("webhook-id");
const webhookTimestamp = request.headers.get("webhook-timestamp");
const webhookSignature = request.headers.get("webhook-signature");

const isSignatureValid = await verifyWebhookSignature(
  env.PARALLEL_WEBHOOK_SECRET,
  webhookId,
  webhookTimestamp,
  body,
  webhookSignature
);

if (result.run.metadata?.isDeep) {
  const competitors = result.output.content?.competitors as any[] | undefined;
  const hostnames = competitors
    ?.map((comp: { hostname: string }) => comp.hostname)
    .filter(Boolean);

  if (hostnames?.length) {
    await Promise.all(
      hostnames.map(async (hostname) => {
        const existingAnalysis = await do_stub.getAnalysis(hostname);

        if (
          existingAnalysis &&
          !existingAnalysis.error &&
          !isAnalysisOld(existingAnalysis.updated_at)
        ) {
          return; // Skip if recent analysis exists
        }

        await performAnalysis(env, do_stub, {
          isDeep: false, // Prevent infinite recursion
          hostname,
          url,
          username,
          profile_image_url,
        });
      })
    );
  }
}

const updateData = {
  company_name: analysisData.company_name || null,
  category: analysisData.category || null,
  business_description: analysisData.business_description || null,
  industry_sector: analysisData.industry_sector || null,
  keywords: analysisData.keywords || null,
};

await do_stub.updateAnalysisResultWithData(
  hostname,
  JSON.stringify(result),
  null,
  updateData
);

export default {
  async fetch(
    request: Request,
    env: Env,
    ctx: ExecutionContext
  ): Promise<Response> {
    const handler = withSimplerAuth<Env>(
      async (request, env, ctx) => {
        const url = new URL(request.url);
        const pathname = url.pathname;

        const do_id = env.COMPETITOR_ANALYSIS.idFromName("v5");
        const do_stub = env.COMPETITOR_ANALYSIS.get(do_id);

        // Route handling logic here...
        switch (pathname) {
          case "/":
            return handleHome(do_stub);
          case "/new":
            return handleNew(request, do_stub, ctx, env);
          // ... other routes
        }
      },
      { isLoginRequired: false }
    );

    return withMcp(handler, openapi, {
      serverInfo: {
        name: "Competitive Analysis MCP",
        version: "1.0.0",
      },
      toolOperationIds: ["getAnalysisMarkdown"],
    })(request, env, ctx);
  },
};

// MCP tool implementation (for /md/ endpoint)
const getAnalysisMarkdown = async (
  hostname: string,
  env: Env
): Promise<string> => {
  const do_id = env.COMPETITOR_ANALYSIS.idFromName("v5");
  const do_stub = env.COMPETITOR_ANALYSIS.get(do_id);

  const analysis = await do_stub.getAnalysis(hostname);
  if (!analysis?.result) {
    throw new Error(`No analysis available for ${hostname}`);
  }

  const result = JSON.parse(analysis.result);
  const primaryData = result.output?.content || {};

  // Get competitor analyses
  const competitors = primaryData.competitors || [];
  const competitorHostnames = competitors
    .map((comp: { hostname: string }) => comp.hostname)
    .filter(Boolean);

  const competitorAnalyses = await Promise.all(
    competitorHostnames.map(async (compHostname: string) => {
      const compAnalysis = await do_stub.getAnalysis(compHostname);
      if (compAnalysis?.status === "done" && compAnalysis.result) {
        const compResult = JSON.parse(compAnalysis.result);
        return {
          hostname: compHostname,
          company_name: compAnalysis.company_name,
          data: compResult.output?.content || {},
        };
      }
      return null;
    })
  );

  const validCompetitorAnalyses = competitorAnalyses.filter(Boolean);

  return buildComprehensiveCompetitiveReport(
    { hostname, company_name: analysis.company_name, data: primaryData },
    validCompetitorAnalyses
  );
};

// Analysis creation requires authentication
if (path === "/new") {
  if (!ctx.authenticated) {
    return renderLoginPage(url.searchParams.get("company"));
  }

  // Rate limiting for users
  const do_id = env.COMPETITOR_ANALYSIS.idFromName("v5");
  const do_stub = env.COMPETITOR_ANALYSIS.get(do_id);

  const userAnalyses = await do_stub.getUserAnalysisCount(
    ctx.user?.username || ""
  );

  if (userAnalyses >= ANALYSES_LIMIT) {
    return new Response(renderRateLimitPage(), {
      headers: { "content-type": "text/html" },
    });
  }

  return handleNewAnalysis(request, env, ctx);
}