types.ts

export const CURRENT_USER_ID = 1;
export const PAGE_SIZE = 12;
export const FEATURED_LISTING_LIMIT = 6;
export const REQUIRED_PHOTO_COUNT = 5;

export const CONDITIONS = ['Mint/Sealed', 'Like New', 'Very Good', 'Good', 'Acceptable'] as const;
export const CATEGORIES = ['Strategy', 'Family', 'Party', 'Cooperative', 'Deck Building', 'Wargame'] as const;
export const PLAYER_COUNT_OPTIONS = ['1', '2', '3-4', '5+'] as const;
export const LOCATIONS = ['Chicago', 'Seattle', 'Austin', 'Denver', 'Portland', 'Boston', 'Minneapolis', 'San Diego'] as const;
export const LISTING_SORT_OPTIONS = ['price-asc', 'price-desc', 'newest', 'popularity'] as const;
export const LISTING_STATUSES = ['active', 'paused', 'sold'] as const;
export const TRANSACTION_STATUSES = ['completed', 'pending_pickup', 'pending_payment'] as const;

export type Condition = (typeof CONDITIONS)[number];
export type Category = (typeof CATEGORIES)[number];
export type PlayerCountFilter = (typeof PLAYER_COUNT_OPTIONS)[number];
export type ListingSort = (typeof LISTING_SORT_OPTIONS)[number];
export type ListingStatus = (typeof LISTING_STATUSES)[number];
export type TransactionStatus = (typeof TRANSACTION_STATUSES)[number];

export type ConfidenceLevel = 'High' | 'Medium' | 'Limited';
export type PricePosition = 'below' | 'fair' | 'above';

export interface ConditionMeta {
  label: Condition;
  colorClass: string;
  softClass: string;
  ringClass: string;
  description: string;
}

export const CONDITION_META: Record<Condition, ConditionMeta> = {
  'Mint/Sealed': {
    label: 'Mint/Sealed',
    colorClass: 'bg-condition-mint/20 text-condition-mint border-condition-mint/40',
    softClass: 'bg-condition-mint/10 text-condition-mint',
    ringClass: 'ring-condition-mint/60',
    description: 'Factory sealed, never opened.',
  },
  'Like New': {
    label: 'Like New',
    colorClass: 'bg-condition-like-new/20 text-condition-like-new border-condition-like-new/40',
    softClass: 'bg-condition-like-new/10 text-condition-like-new',
    ringClass: 'ring-condition-like-new/60',
    description: 'Opened once or twice with perfect components and no marks.',
  },
  'Very Good': {
    label: 'Very Good',
    colorClass: 'bg-condition-very-good/20 text-condition-very-good border-condition-very-good/40',
    softClass: 'bg-condition-very-good/10 text-condition-very-good',
    ringClass: 'ring-condition-very-good/60',
    description: 'Light play with minor shelf wear and all components included.',
  },
  Good: {
    label: 'Good',
    colorClass: 'bg-condition-good/20 text-condition-good border-condition-good/40',
    softClass: 'bg-condition-good/10 text-condition-good',
    ringClass: 'ring-condition-good/60',
    description: 'Regular play with visible wear and all components present.',
  },
  Acceptable: {
    label: 'Acceptable',
    colorClass: 'bg-condition-acceptable/20 text-condition-acceptable border-condition-acceptable/40',
    softClass: 'bg-condition-acceptable/10 text-condition-acceptable',
    ringClass: 'ring-condition-acceptable/60',
    description: 'Heavy wear with any missing or damaged components clearly disclosed.',
  },
};

export interface User {
  id: number;
  username: string;
  displayName: string;
  email: string;
  avatarInitials: string;
  location: string;
  memberSince: string;
  rating: number;
  reviewCount: number;
  completedTransactions: number;
  bggUsername: string;
}

/** User data safe to expose in public API responses (email omitted). */
export type PublicUser = Omit<User, 'email'>;

export interface Game {
  id: number;
  title: string;
  publisher: string;
  year: number;
  minPlayers: number;
  maxPlayers: number;
  playTimeMin: number;
  playTimeMax: number;
  category: Category;
  description: string;
  imageColor: string;
  bggRating: number;
}

export interface GameComponent {
  id: number;
  gameId: number;
  componentName: string;
  quantity: number;
}

export interface Listing {
  id: number;
  gameId: number;
  sellerId: number;
  condition: Condition;
  price: number;
  description: string;
  location: string;
  status: ListingStatus;
  createdAt: string;
  views: number;
  saves: number;
}

export interface Transaction {
  id: number;
  listingId: number;
  buyerId: number;
  sellerId: number;
  price: number;
  status: TransactionStatus;
  completedAt: string;
}

export interface Review {
  id: number;
  reviewerId: number;
  revieweeId: number;
  transactionId: number;
  stars: number;
  text: string;
  createdAt: string;
}

export interface Watchlist {
  id: number;
  userId: number;
  gameId: number;
  createdAt: string;
}

export interface TradeWant {
  id: number;
  userId: number;
  gameId: number;
  createdAt: string;
}

export interface TradeHave {
  id: number;
  userId: number;
  gameId: number;
  createdAt: string;
}

export interface PriceHistory {
  id: number;
  gameId: number;
  condition: Condition;
  price: number;
  recordedAt: string;
}

export interface SellerSummary {
  id: number;
  username: string;
  displayName: string;
  rating: number;
  avatarInitials: string;
  reviewCount?: number;
  completedTransactions?: number;
}

export interface ListingCardData {
  id: number;
  gameId: number;
  title: string;
  condition: Condition;
  price: number;
  location: string;
  seller: SellerSummary;
  imageColor: string;
  createdAt: string;
  views: number;
  saves: number;
  status: ListingStatus;
}

export interface ReviewSummary {
  id: number;
  reviewerUsername: string;
  reviewerDisplayName: string;
  stars: number;
  text: string;
  createdAt: string;
}

export interface ListingDetailData {
  listing: ListingCardData & {
    description: string;
  };
  sellerReviews: ReviewSummary[];
  game: Game & {
    components: GameComponent[];
  };
}

export type PriceHistoryChartPoint = {
  month: string;
} & Partial<Record<Condition, number>>;

export interface MarketValue {
  low: number;
  high: number;
  confidence: ConfidenceLevel;
}

export interface GameDetailData {
  game: Game;
  components: GameComponent[];
  activeListings: ListingCardData[];
  priceHistory: PriceHistory[];
  chartData: PriceHistoryChartPoint[];
  similarGames: Game[];
  marketValue: MarketValue;
}

export interface ListingSearchFilters {
  search?: string;
  conditions?: Condition[];
  category?: Category;
  minPrice?: number;
  maxPrice?: number;
  location?: string;
  sort?: ListingSort;
  page?: number;
  players?: PlayerCountFilter;
}

export interface ListingSearchResult {
  items: ListingCardData[];
  total: number;
  page: number;
  pageSize: number;
}

export interface GameSearchFilters {
  search?: string;
  category?: Category;
}

export interface GameSearchResult {
  items: Game[];
}

export interface ProfileReview {
  id: number;
  reviewerUsername: string;
  reviewerDisplayName: string;
  stars: number;
  text: string;
  createdAt: string;
}

export interface ProfileData {
  user: PublicUser;
  reputation: {
    averageRating: number;
    reviewCount: number;
    completionRate: number;
  };
  activeListings: ListingCardData[];
  reviews: ProfileReview[];
}

export interface TransactionRow {
  id: number;
  listingId: number;
  gameTitle: string;
  counterpartName: string;
  price: number;
  date: string;
  status: TransactionStatus;
  role: 'buy' | 'sell';
}

export interface WatchlistEntry {
  id: number;
  gameId: number;
  title: string;
  category: Category;
  createdAt: string;
  imageColor: string;
}

export interface SavedSearchEntry {
  id: number;
  name: string;
  query: string;
  createdAt: string;
}

export interface DashboardData {
  stats: {
    activeListings: number;
    totalSales: number;
    collectionValue: number;
    reputationScore: number;
  };
  activeListings: ListingCardData[];
  salesHistory: TransactionRow[];
  purchaseHistory: TransactionRow[];
  watchlist: WatchlistEntry[];
  savedSearches: SavedSearchEntry[];
  collectionValueByCategory: Array<{
    category: Category;
    value: number;
  }>;
}

export interface TradeMatch {
  partner: {
    id: number;
    username: string;
    displayName: string;
    location: string;
    rating: number;
    avatarInitials: string;
  };
  theyHave: Game[];
  theyWant: Game[];
  summary: string;
}

export interface CreateListingInput {
  gameId: number;
  condition: Condition;
  price: number;
  description: string;
  location: string;
  sellerId: number;
}

export interface AutocompleteOption {
  id: number | string;
  label: string;
  sublabel?: string;
}

export interface ApiResponse<T> {
  data: T | null;
  error: string | null;
}