import { Hono } from "hono";
import { eq, and } from "drizzle-orm";
import { filter } from "../../../db/schema";
import { authenticate } from "../middleware/auth";
import { createDatabase } from "../utils/database";
import { standardErrorResponse } from "../utils/errorHandler";
import type { Env } from "../types";
const filters = new Hono<{ Bindings: Env }>();
/**
 * Protected API route to validate that a filter exists by name
 * 
 * @route POST /api/filters/validate
 * @authentication Required
 * @param {string} name - Required body parameter specifying the filter name to validate
 * @returns {Object} Response containing:
 *   - data: Object with filter id and name if found
 * @error 400 - If name parameter is missing or invalid
 * @error 404 - If filter is not found
 * @error 500 - If database operation fails
 * @description Validates that a filter with the specified name exists and is active.
 *   Used during selection import to ensure the parsed filter name from the folder
 *   corresponds to an actual filter in the database.
 *   
 *   Request body:
 *   {
 *     "name": "opensoundscape-kiwi-1.2"
 *   }
 *   
 *   Response on success:
 *   {
 *     "data": {
 *       "id": "filter123",
 *       "name": "opensoundscape-kiwi-1.2"
 *     }
 *   }
 */
filters.post("/validate", authenticate, async (c) => {
  try {
    // Note: User authentication is handled by the authenticate middleware
    // Future enhancement could add user-specific filter permissions
    
    // Parse request body
    const body = await c.req.json();
    const { name } = body;
    
    // Validate required parameters
    if (!name || typeof name !== 'string') {
      return c.json({
        error: "Missing or invalid required parameter: name must be a non-empty string"
      }, 400);
    }
    
    // Connect to the database
    const db = createDatabase(c.env);
    
    // Query for the filter by name
    const filterResult = await db
      .select({
        id: filter.id,
        name: filter.name,
      })
      .from(filter)
      .where(
        and(
          eq(filter.name, name),
          eq(filter.active, true)
        )
      )
      .limit(1);
    
    if (filterResult.length === 0) {
      return c.json({
        error: `Filter not found: '${name}'`
      }, 404);
    }
    
    const foundFilter = filterResult[0];
    console.log(`Filter validation successful: ${name} -> ${foundFilter.id}`);
    
    return c.json({
      data: {
        id: foundFilter.id,
        name: foundFilter.name
      }
    });
    
  } catch (error) {
    return c.json(standardErrorResponse(error, "validating filter"), 500);
  }
});
export default filters;