import type {
  Schema,
  ReferenceSchema,
  ReverseReferenceSchema,
} from "../types.js";

export interface CsvLoaderOptions {
  delimiter?: string;
  quote?: string;
  escape?: string;
  bom?: boolean;
  comment?: string | false;
  trim?: boolean;
  /** Generate TypeScript declaration file (.d.ts) */
  emitTypes?: boolean;
  /** Output directory for generated type files (relative to output path) */
  typesOutputDir?: string;
  /** Write .d.ts files to disk (useful for dev server) */
  writeToDisk?: boolean;
  /** Base directory for resolving referenced CSV files (default: directory of current file) */
  refBaseDir?: string;
  /** Primary key field name for referenced tables (default: 'id') */
  defaultPrimaryKey?: string;
  /** Current file path (used to resolve relative references) */
  currentFilePath?: string;
  /**
   * When false, reference fields store parsed IDs instead of resolved objects.
   * Used by csvToModule to emit accessor-based code with lazy resolution.
   * Default: true (resolves references eagerly by loading referenced CSV files).
   */
  resolveReferences?: boolean;
}

export interface ReferenceFieldInfo {
  /** Column name in the CSV */
  name: string;
  /** Referenced table name */
  tableName: string;
  /** Whether it's an array reference */
  isArray: boolean;
  /** The schema of this field (for nested references) */
  schema: Schema;
  /** For reverse references: the foreign key field name in the referenced table */
  foreignKey?: string;
}

export interface CsvParseResult {
  /** Parsed CSV data as array of objects */
  data: Record<string, unknown>[];
  /** Generated TypeScript type definition string (if emitTypes is true) */
  typeDefinition?: string;
  /** Property configurations for the CSV columns */
  propertyConfigs: PropertyConfig[];
  /** Referenced table names */
  references: Set<string>;
  /** Reference field metadata (populated when resolveReferences is false) */
  referenceFields: ReferenceFieldInfo[];
  /** Reverse reference declarations parsed from comment lines */
  reverseReferences: ReverseReferenceDeclaration[];
}

export interface PropertyConfig {
  name: string;
  schema: any;
  validator: (value: unknown) => boolean;
  parser: (valueString: string) => unknown;
  /** Whether this property is a reference to another table */
  isReference?: boolean;
  /** Referenced table name (if isReference is true) */
  referenceTableName?: string;
  /** Whether it's an array reference */
  referenceIsArray?: boolean;
  /** Whether this is a reverse reference (one-to-many) */
  isReverseReference?: boolean;
  /** Foreign key field name for reverse references */
  reverseReferenceForeignKey?: string;
}

/** Parsed reverse reference declaration from a comment line */
export interface ReverseReferenceDeclaration {
  /** Field name in the current table */
  fieldName: string;
  /** Referenced table name */
  tableName: string;
  /** Foreign key field name in the referenced table */
  foreignKey: string;
  /** Whether it's optional */
  isOptional: boolean;
  /** The parsed schema */
  schema: ReverseReferenceSchema;
}