/**
 * Standardized logging utilities for consistent log formatting
 */
/**
 * Log levels for different types of operations
 */
export enum LogLevel {
  ERROR = 'ERROR',
  WARN = 'WARN', 
  INFO = 'INFO',
  DEBUG = 'DEBUG'
}
/**
 * Standard log entry structure
 */
interface LogEntry {
  level: LogLevel;
  operation: string;
  userId?: string;
  resourceType?: string;
  resourceId?: string;
  details?: Record<string, unknown> | undefined;
  error?: Error | string;
}
/**
 * Formats a log entry consistently
 */
function formatLogEntry(entry: LogEntry): string {
  const timestamp = new Date().toISOString();
  const parts = [`[${timestamp}]`, `[${entry.level}]`, entry.operation];
  
  if (entry.userId) {
    parts.push(`user:${entry.userId}`);
  }
  
  if (entry.resourceType && entry.resourceId) {
    parts.push(`${entry.resourceType}:${entry.resourceId}`);
  }
  
  if (entry.details && Object.keys(entry.details).length > 0) {
    parts.push(JSON.stringify(entry.details));
  }
  
  return parts.join(' ');
}
/**
 * Logs CRUD operations with standardized format
 */
export function logCrudOperation(
  operation: 'CREATE' | 'UPDATE' | 'DELETE',
  resourceType: string,
  resourceId: string,
  userId: string,
  details?: Record<string, unknown>
): void {
  const entry: LogEntry = {
    level: LogLevel.INFO,
    operation,
    userId,
    resourceType,
    resourceId,
    details
  };
  
  console.info(formatLogEntry(entry));
}
/**
 * Logs authentication/authorization events
 */
export function logAuthEvent(
  event: string,
  userId: string,
  details?: Record<string, unknown>
): void {
  const entry: LogEntry = {
    level: LogLevel.INFO,
    operation: 'AUTH',
    userId,
    details: { event, ...details }
  };
  
  console.info(formatLogEntry(entry));
}
/**
 * Logs errors with context
 */
export function logError(
  operation: string,
  error: Error | string,
  context?: Record<string, unknown>
): void {
  const entry: LogEntry = {
    level: LogLevel.ERROR,
    operation,
    error,
    details: context
  };
  
  console.error(formatLogEntry(entry), error);
}
/**
 * Logs debug information (only in development)
 */
export function logDebug(
  operation: string,
  details: Record<string, unknown>
): void {
  // Only log debug in development environments
  if (process.env.NODE_ENV === 'development') {
    const entry: LogEntry = {
      level: LogLevel.DEBUG,
      operation,
      details
    };
    
    console.debug(formatLogEntry(entry));
  }
}

// Type for the database connection
export type Database = ReturnType<typeof createDatabase>;

export function transformCallRateRows(rows: any[]): import("./types").CallRateRow[] {
  return rows.map(row => ({
    hour_of_day: Number(row.hour_of_day),
    call_count: Number(row.call_count),
    total_recording_hours: Number(row.total_recording_hours),
    call_rate_per_hour: Number(row.call_rate_per_hour)
  }));

export function transformCallRateRows(rows: unknown[]): import("./types").CallRateRow[] {
  return rows.map(row => {
    const r = row as Record<string, unknown>;
    return {
      hour_of_day: Number(r.hour_of_day),
      call_count: Number(r.call_count),
      total_recording_hours: Number(r.total_recording_hours),
      call_rate_per_hour: Number(r.call_rate_per_hour)
    };
  });

export function transformSpeciesRows(rows: any[]): import("./types").SpeciesRow[] {
  return rows.map(row => ({
    id: row.id as string,
    label: row.label as string,
    ebird_code: row.ebird_code as string | null
  }));

export function transformSpeciesRows(rows: unknown[]): import("./types").SpeciesRow[] {
  return rows.map(row => {
    const r = row as Record<string, unknown>;
    return {
      id: r.id as string,
      label: r.label as string,
      ebird_code: r.ebird_code as string | null
    };
  });

export function transformCallTypeRows(rows: any[]): import("./types").CallTypeRow[] {
  return rows.map(row => ({
    id: row.id as string,
    label: row.label as string
  }));

export function transformCallTypeRows(rows: unknown[]): import("./types").CallTypeRow[] {
  return rows.map(row => {
    const r = row as Record<string, unknown>;
    return {
      id: r.id as string,
      label: r.label as string
    };
  });

export function transformFilterRows(rows: any[]): import("./types").FilterRow[] {
  return rows.map(row => ({
    id: row.id as string,
    name: row.name as string
  }));

export function transformFilterRows(rows: unknown[]): import("./types").FilterRow[] {
  return rows.map(row => {
    const r = row as Record<string, unknown>;
    return {
      id: r.id as string,
      name: r.name as string
    };
  });

import { sql } from "drizzle-orm";

import { sql, eq, and } from "drizzle-orm";
import { cluster } from "../../../../db/schema";
import type { Database } from "../../utils/database";

export async function getDatasetSpecies(db: any, datasetId: string) {

export async function getDatasetSpecies(db: Database, datasetId: string) {

export async function getSpeciesCallTypes(db: any, speciesId: string) {

export async function getSpeciesCallTypes(db: Database, speciesId: string) {

export async function getClusterFilters(db: any, clusterId: string) {

export async function getClusterFilters(db: Database, clusterId: string) {

export async function getDatasetFilters(db: any, datasetId: string) {

export async function getDatasetFilters(db: Database, datasetId: string) {

export async function getClusterDataset(db: any, clusterId: string) {
  return db.execute(sql`
    SELECT dataset_id FROM cluster WHERE id = ${clusterId} AND active = true
  `);

export async function getClusterDataset(db: Database, clusterId: string) {
  return db
    .select({ dataset_id: cluster.datasetId })
    .from(cluster)
    .where(and(eq(cluster.id, clusterId), eq(cluster.active, true)))
    .limit(1);

export async function getClusterCallRatePerHour(db: any, params: CallRateQueryParams) {

export async function getClusterCallRatePerHour(db: Database, params: CallRateQueryParams) {

export async function getDatasetCallRatePerHour(db: any, params: CallRateQueryParams) {

export async function getDatasetCallRatePerHour(db: Database, params: CallRateQueryParams) {

export async function getClusterCallRateMetadata(db: any, params: CallRateQueryParams): Promise<QueryMetadata> {

export async function getClusterCallRateMetadata(db: Database, params: CallRateQueryParams): Promise<QueryMetadata> {

export async function getDatasetCallRateMetadata(db: any, params: CallRateQueryParams): Promise<QueryMetadata> {

export async function getDatasetCallRateMetadata(db: Database, params: CallRateQueryParams): Promise<QueryMetadata> {

    if (clusterResult.rows.length === 0) {

    if (clusterResult.length === 0) {

    const datasetId = clusterResult.rows[0].dataset_id as string;

    const datasetId = clusterResult[0].dataset_id;

    if (clusterResult.rows.length === 0) {

    if (clusterResult.length === 0) {

    const datasetId = clusterResult.rows[0].dataset_id as string;

    const datasetId = clusterResult[0].dataset_id;

    
    const { page, pageSize, offset } = paginationResult.params;

    console.log("Selections API called with datasetId:", datasetId, "speciesId:", speciesId, "page:", page);

    const { pageSize, offset } = paginationResult.params;

import { eq, sql as sqlExpr } from "drizzle-orm";

import { eq, and, count } from "drizzle-orm";

      console.log("Missing datasetId in request");

    const { page, pageSize, offset } = paginationResult.params;

    const { pageSize, offset } = paginationResult.params;

    console.log("Locations API called with datasetId:", datasetId, "userId:", userId, "page:", page);
    

    console.log("Counting locations for datasetId:", datasetId);

        count: sqlExpr<number>`COUNT(*)`

        count: count()

      .where(sqlExpr`${location.datasetId} = ${datasetId} AND ${location.active} = true`);

      .where(and(eq(location.datasetId, datasetId), eq(location.active, true)));

    console.log("Querying locations for datasetId:", datasetId, "page:", page);

      .where(sqlExpr`${location.datasetId} = ${datasetId} AND ${location.active} = true`)

      .where(and(eq(location.datasetId, datasetId), eq(location.active, true)))

    
    console.log("Found", results.length, "locations for dataset", datasetId, "page:", page);

import { eq, sql as sqlExpr, inArray, and } from "drizzle-orm";

import { eq, sql as sqlExpr, inArray, and, or, isNull } from "drizzle-orm";

      console.log("Missing clusterId in request");

    
    const { page, pageSize, offset } = paginationResult.params;

    console.log("Files API called with clusterId:", clusterId, "page:", page, "pageSize:", pageSize);

    const { pageSize, offset } = paginationResult.params;

    // Build filter conditions
    let whereConditions = sqlExpr`${file.clusterId} = ${clusterId} AND ${file.active} = true`;

    // Build filter conditions using Drizzle ORM
    const baseConditions = [
      eq(file.clusterId, clusterId),
      eq(file.active, true)
    ];

      whereConditions = sqlExpr`${whereConditions} AND ${file.maybeSolarNight} = true`;

      baseConditions.push(eq(file.maybeSolarNight, true));

      whereConditions = sqlExpr`${whereConditions} AND (${file.maybeSolarNight} = false OR ${file.maybeSolarNight} IS NULL)`;

      baseConditions.push(or(eq(file.maybeSolarNight, false), isNull(file.maybeSolarNight))!);

      whereConditions = sqlExpr`${whereConditions} AND ${file.maybeCivilNight} = true`;

      baseConditions.push(eq(file.maybeCivilNight, true));

      whereConditions = sqlExpr`${whereConditions} AND (${file.maybeCivilNight} = false OR ${file.maybeCivilNight} IS NULL)`;

      baseConditions.push(or(eq(file.maybeCivilNight, false), isNull(file.maybeCivilNight))!);

    const whereConditions = and(...baseConditions);
    

import { logCrudOperation } from "../utils/logging";

    console.log("Created dataset:", result[0].id, "for user:", userId);

    logCrudOperation('CREATE', 'dataset', result[0].id, userId, {
      name: result[0].name,
      type: result[0].type,
      public: result[0].public
    });

    console.log("Updated dataset:", result[0].id, "for user:", userId);

    logCrudOperation('UPDATE', 'dataset', result[0].id, userId, {
      updatedFields: Object.keys(updateData).filter(key => key !== 'lastModified' && key !== 'modifiedBy')
    });

import { logCrudOperation } from "../utils/logging";

    console.log("Created cluster:", result.id, "for location:", locationId, "by user:", userId);

    logCrudOperation('CREATE', 'cluster', result.id, userId, { locationId, name: result.name });

    console.log("Updated cluster:", result.id, "by user:", userId);

    logCrudOperation('UPDATE', 'cluster', result.id, userId);

    console.log("Soft deleted cluster:", clusterId, "and soft deleted associated recording pattern by user:", userId);

    logCrudOperation('DELETE', 'cluster', clusterId, userId, { softDelete: true });