import { v } from "convex/values";
import { mutation, query, internalQuery } from "./_generated/server";
import {
  feedbackTypeValidator,
  bugSeverityValidator,
} from "./schema";

// Return type for support team records
const supportTeamReturnValidator = v.object({
  _id: v.id("supportTeams"),
  _creationTime: v.number(),
  teamName: v.string(),
  memberEmails: v.array(v.string()),
  feedbackTypes: v.array(feedbackTypeValidator),
  bugReportSeverities: v.array(bugSeverityValidator),
  isActive: v.boolean(),
  createdAt: v.number(),
  updatedAt: v.number(),
});

/**
 * List all support teams.
 */
export const list = query({
  args: {
    activeOnly: v.optional(v.boolean()),
  },
  returns: v.array(supportTeamReturnValidator),
  handler: async (ctx, args) => {
    if (args.activeOnly) {
      return await ctx.db
        .query("supportTeams")
        .withIndex("by_active", (q) => q.eq("isActive", true))
        .collect();
    }
    return await ctx.db.query("supportTeams").collect();
  },
});

/**
 * Get a support team by ID.
 */
export const get = query({
  args: {
    teamId: v.id("supportTeams"),
  },
  returns: v.union(supportTeamReturnValidator, v.null()),
  handler: async (ctx, args) => {
    return await ctx.db.get(args.teamId);
  },
});

/**
 * Internal query to find all active teams that handle a given feedback type.
 */
export const getTeamsForFeedbackType = internalQuery({
  args: {
    feedbackType: feedbackTypeValidator,
  },
  returns: v.array(supportTeamReturnValidator),
  handler: async (ctx, args) => {
    const allTeams = await ctx.db
      .query("supportTeams")
      .withIndex("by_active", (q) => q.eq("isActive", true))
      .collect();

    return allTeams.filter((team) =>
      team.feedbackTypes.includes(args.feedbackType)
    );
  },
});

/**
 * Internal query to find all active teams that handle a given bug report severity.
 */
export const getTeamsForBugReportSeverity = internalQuery({
  args: {
    severity: bugSeverityValidator,
  },
  returns: v.array(supportTeamReturnValidator),
  handler: async (ctx, args) => {
    const allTeams = await ctx.db
      .query("supportTeams")
      .withIndex("by_active", (q) => q.eq("isActive", true))
      .collect();

    return allTeams.filter((team) =>
      team.bugReportSeverities.includes(args.severity)
    );
  },
});

/**
 * Create a new support team.
 */
export const create = mutation({
  args: {
    teamName: v.string(),
    memberEmails: v.array(v.string()),
    feedbackTypes: v.array(feedbackTypeValidator),
    bugReportSeverities: v.array(bugSeverityValidator),
  },
  returns: v.id("supportTeams"),
  handler: async (ctx, args) => {
    const now = Date.now();
    return await ctx.db.insert("supportTeams", {
      teamName: args.teamName,
      memberEmails: args.memberEmails,
      feedbackTypes: args.feedbackTypes,
      bugReportSeverities: args.bugReportSeverities,
      isActive: true,
      createdAt: now,
      updatedAt: now,
    });
  },
});

/**
 * Update a support team.
 */
export const update = mutation({
  args: {
    teamId: v.id("supportTeams"),
    teamName: v.optional(v.string()),
    memberEmails: v.optional(v.array(v.string())),
    feedbackTypes: v.optional(v.array(feedbackTypeValidator)),
    bugReportSeverities: v.optional(v.array(bugSeverityValidator)),
    isActive: v.optional(v.boolean()),
  },
  returns: v.null(),
  handler: async (ctx, args) => {
    const team = await ctx.db.get(args.teamId);
    if (!team) {
      throw new Error("Support team not found");
    }

    const updates: Record<string, unknown> = {
      updatedAt: Date.now(),
    };

    if (args.teamName !== undefined) {
      updates.teamName = args.teamName;
    }
    if (args.memberEmails !== undefined) {
      updates.memberEmails = args.memberEmails;
    }
    if (args.feedbackTypes !== undefined) {
      updates.feedbackTypes = args.feedbackTypes;
    }
    if (args.bugReportSeverities !== undefined) {
      updates.bugReportSeverities = args.bugReportSeverities;
    }
    if (args.isActive !== undefined) {
      updates.isActive = args.isActive;
    }

    await ctx.db.patch(args.teamId, updates);
    return null;
  },
});

/**
 * Delete a support team.
 */
export const remove = mutation({
  args: {
    teamId: v.id("supportTeams"),
  },
  returns: v.null(),
  handler: async (ctx, args) => {
    const team = await ctx.db.get(args.teamId);
    if (!team) {
      throw new Error("Support team not found");
    }

    await ctx.db.delete(args.teamId);
    return null;
  },
});