/**
 * Data Sheriff Agent - Type Definitions
 * Sports Query Resolution Agent for database-chat integration
 */

// Entity Types
export type EntityType = 'player' | 'team' | 'date' | 'event' | 'metric' | 'strategy' | 'league';

export interface ResolvedEntity {
  type: EntityType;
  raw: string;           // Original text from query
  canonical: string;     // Resolved canonical name
  id?: string | number;  // Database ID if found
  confidence: number;    // 0-1 confidence score
  alternatives?: Array<{ value: string; confidence: number }>;
  metadata?: Record<string, unknown>;
}

export interface PlayerEntity extends ResolvedEntity {
  type: 'player';
  playerId?: string;
  externalPlayerId?: string;
  team?: string;
  position?: string;
  league: string;
  isActive?: boolean;
  injuryStatus?: string;
}

export interface TeamEntity extends ResolvedEntity {
  type: 'team';
  teamId?: string;
  abbreviation?: string;
  city?: string;
  league: string;
}

export interface DateEntity extends ResolvedEntity {
  type: 'date';
  startDate: Date;
  endDate: Date;
  isRange: boolean;
  season?: number;
  week?: number;
  periodType?: 'game' | 'week' | 'month' | 'season' | 'playoffs';
}

export interface EventEntity extends ResolvedEntity {
  type: 'event';
  eventType: 'game' | 'series' | 'tournament' | 'championship';
  gameId?: string;
  league: string;
  date?: Date;
}

export interface MetricEntity extends ResolvedEntity {
  type: 'metric';
  metricKey: string;     // e.g., 'points', 'spread', 'over_under'
  category: 'stat' | 'betting' | 'derived';
}

// Query Intent Classification
export type QueryIntent =
  | 'historical_performance'
  | 'strategy_backtesting'
  | 'player_comparison'
  | 'team_comparison'
  | 'future_prediction'
  | 'odds_lookup'
  | 'injury_check'
  | 'general_knowledge'
  | 'prop_lookup'
  | 'trend_analysis';

export interface IntentClassification {
  primary: QueryIntent;
  confidence: number;
  secondary?: QueryIntent;
  secondaryConfidence?: number;
}

// Data Coverage
export interface CoverageReport {
  overall: number;       // 0-1 overall coverage score
  breakdown: {
    playerStats: number;
    gameData: number;
    bettingLines: number;
    props: number;
    injuries: number;
  };
  gaps: DataGap[];
  suggestions: string[];
}

export interface DataGap {
  type: string;
  description: string;
  severity: 'critical' | 'moderate' | 'minor';
  workaround?: string;
}

// Query Deconstruction
export interface DeconstructedQuery {
  originalQuery: string;
  normalizedQuery: string;
  entities: ResolvedEntity[];
  intent: IntentClassification;
  timeframe?: DateEntity;
  league?: string;
  sport?: string;
  expandedQueries?: string[];
}

// Validation Result
export interface ValidationResult {
  isValid: boolean;
  confidence: number;
  corrections: QueryCorrection[];
  warnings: string[];
  enrichedContext: EnrichedContext;
}

export interface QueryCorrection {
  original: string;
  corrected: string;
  reason: string;
  confidence: number;
  applied: boolean;
}

export interface EnrichedContext {
  resolvedEntities: ResolvedEntity[];
  coverage: CoverageReport;
  relatedData: Record<string, unknown>;
  dataQualityFlags: string[];
  inferredData?: InferredData[];
}

export interface InferredData {
  field: string;
  value: unknown;
  basis: string;       // How it was inferred
  confidence: number;
  isActual: boolean;   // false = inferred, true = actual data
}

// Agent Response
export interface DataSheriffResponse {
  success: boolean;
  deconstructedQuery: DeconstructedQuery;
  validation: ValidationResult;
  enhancedQuery: string;
  contextForLLM: string;
  processingTimeMs: number;
  metadata: {
    entitiesResolved: number;
    correctionsApplied: number;
    coverageScore: number;
    confidenceScore: number;
  };
}

// Configuration
export interface DataSheriffConfig {
  minConfidenceThreshold: number;
  enableFuzzyMatching: boolean;
  maxFuzzyDistance: number;
  enableInference: boolean;
  inferenceConfidenceThreshold: number;
  maxResponseTimeMs: number;
  enableCaching: boolean;
  cacheTTLSeconds: number;
}

// League and Sport Mappings
export const LEAGUE_SPORT_MAP: Record<string, string> = {
  'nba': 'basketball',
  'wnba': 'basketball',
  'ncaab': 'basketball',
  'nfl': 'football',
  'ncaaf': 'football',
  'mlb': 'baseball',
  'nhl': 'hockey',
  'mls': 'soccer',
  'epl': 'soccer',
  'ufc': 'mma',
  'pga': 'golf',
};

export const SPORT_LEAGUES_MAP: Record<string, string[]> = {
  'basketball': ['nba', 'wnba', 'ncaab'],
  'football': ['nfl', 'ncaaf'],
  'baseball': ['mlb'],
  'hockey': ['nhl'],
  'soccer': ['mls', 'epl', 'laliga', 'bundesliga', 'seriea'],
  'mma': ['ufc', 'bellator'],
  'golf': ['pga', 'lpga'],
};

// Common nicknames and aliases
export const PLAYER_NICKNAMES: Record<string, string> = {
  // NBA
  'king james': 'LeBron James',
  'lebron': 'LeBron James',
  'mj': 'Michael Jordan',
  'chef curry': 'Stephen Curry',
  'steph': 'Stephen Curry',
  'steph curry': 'Stephen Curry',
  'kd': 'Kevin Durant',
  'the beard': 'James Harden',
  'greek freak': 'Giannis Antetokounmpo',
  'giannis': 'Giannis Antetokounmpo',
  'ad': 'Anthony Davis',
  'pg13': 'Paul George',
  'cp3': 'Chris Paul',
  'joker': 'Nikola Jokić',
  'jokic': 'Nikola Jokić',
  'nikola jokic': 'Nikola Jokić',
  'luka': 'Luka Dončić',
  'luka doncic': 'Luka Dončić',
  'doncic': 'Luka Dončić',
  'vucevic': 'Nikola Vučević',
  'nikola vucevic': 'Nikola Vučević',
  'bogdanovic': 'Bogdan Bogdanović',
  'bogdan bogdanovic': 'Bogdan Bogdanović',
  'ja': 'Ja Morant',
  'ant': 'Anthony Edwards',
  'ant man': 'Anthony Edwards',
  'dame': 'Damian Lillard',
  'dame time': 'Damian Lillard',
  'kyrie': 'Kyrie Irving',
  'jimmy buckets': 'Jimmy Butler',
  'jimmy butler': 'Jimmy Butler',
  'bam': 'Bam Adebayo',
  'book': 'Devin Booker',
  'tatum': 'Jayson Tatum',
  'jb': 'Jaylen Brown',
  // NFL
  'tb12': 'Tom Brady',
  'mahomes': 'Patrick Mahomes',
  'lamar': 'Lamar Jackson',
  'josh allen': 'Josh Allen',
  'burrow': 'Joe Burrow',
  'hurts': 'Jalen Hurts',
  'cmc': 'Christian McCaffrey',
  'derrick henry': 'Derrick Henry',
  'king henry': 'Derrick Henry',
  'kelce': 'Travis Kelce',
  'tyreek': 'Tyreek Hill',
  'davante': 'Davante Adams',
  'diggs': 'Stefon Diggs',
  'jj watt': 'J.J. Watt',
  'aaron donald': 'Aaron Donald',
  'myles garrett': 'Myles Garrett',
  // NHL
  'the great one': 'Wayne Gretzky',
  'ovie': 'Alexander Ovechkin',
  'ovi': 'Alexander Ovechkin',
  'crosby': 'Sidney Crosby',
  'sid the kid': 'Sidney Crosby',
  'mcdavid': 'Connor McDavid',
  'mcdaddy': 'Connor McDavid',
  'matthews': 'Auston Matthews',
  'makar': 'Cale Makar',
  'kucherov': 'Nikita Kucherov',
  // MLB
  'trout': 'Mike Trout',
  'shohei': 'Shohei Ohtani',
  'ohtani': 'Shohei Ohtani',
  'judge': 'Aaron Judge',
  'mookie': 'Mookie Betts',
  'tatis': 'Fernando Tatis Jr.',
  'vladdy': 'Vladimir Guerrero Jr.',
  'acuna': 'Ronald Acuna Jr.',
  'soto': 'Juan Soto',
  'trea': 'Trea Turner',
  'degrom': 'Jacob deGrom',
};

export const TEAM_ALIASES: Record<string, { name: string; league: string }> = {
  'lakers': { name: 'Los Angeles Lakers', league: 'nba' },
  'celtics': { name: 'Boston Celtics', league: 'nba' },
  'warriors': { name: 'Golden State Warriors', league: 'nba' },
  'heat': { name: 'Miami Heat', league: 'nba' },
  'bulls': { name: 'Chicago Bulls', league: 'nba' },
  'knicks': { name: 'New York Knicks', league: 'nba' },
  'nets': { name: 'Brooklyn Nets', league: 'nba' },
  'chiefs': { name: 'Kansas City Chiefs', league: 'nfl' },
  'eagles': { name: 'Philadelphia Eagles', league: 'nfl' },
  'cowboys': { name: 'Dallas Cowboys', league: 'nfl' },
  '49ers': { name: 'San Francisco 49ers', league: 'nfl' },
  'niners': { name: 'San Francisco 49ers', league: 'nfl' },
  'patriots': { name: 'New England Patriots', league: 'nfl' },
  'yankees': { name: 'New York Yankees', league: 'mlb' },
  'dodgers': { name: 'Los Angeles Dodgers', league: 'mlb' },
  'red sox': { name: 'Boston Red Sox', league: 'mlb' },
  'cubs': { name: 'Chicago Cubs', league: 'mlb' },
  'maple leafs': { name: 'Toronto Maple Leafs', league: 'nhl' },
  'leafs': { name: 'Toronto Maple Leafs', league: 'nhl' },
  'bruins': { name: 'Boston Bruins', league: 'nhl' },
  'oilers': { name: 'Edmonton Oilers', league: 'nhl' },
};