types.ts

// General
export interface EpisodesInfo {
  sub: number;
  dub: number;
}

export interface BaseAnime {
  id: string;
  name: string;
  poster: string;
  type?: string;
  episodes?: EpisodesInfo;
  isAdult?: boolean; // Added for 18+ content
}

export interface RankedAnime extends BaseAnime {
  rank: number;
}

export interface DetailedAnime extends BaseAnime {
  jname?: string;
  duration?: string;
  rating?: string;
}

// Home Page
export interface SpotlightAnime extends DetailedAnime {
  description: string;
  rank: number;
  otherInfo: string[];
}

export interface TopAiringAnimeHome extends DetailedAnime {
    // jname is already in DetailedAnime
}

export interface ScheduledAnimeToday { // For LType today.schedule
  id: string;
  title: string;
  jname?: string; // japanese_title
  time: string; // release time
  episode?: number; // episode_no
  poster?: string; // Not in LType schedule, but good for display consistency if available elsewhere
}

export interface HomePageData {
  genres: string[];
  latestEpisodeAnimes: BaseAnime[];
  spotlightAnimes: SpotlightAnime[];
  top10Animes: {
    today: RankedAnime[];
    week: RankedAnime[];
    month: RankedAnime[];
  };
  topAiringAnimes: TopAiringAnimeHome[];
  topUpcomingAnimes: DetailedAnime[];
  trendingAnimes: RankedAnime[];
  mostPopularAnimes: BaseAnime[];
  mostFavoriteAnimes: BaseAnime[];
  latestCompletedAnimes: BaseAnime[];
  scheduledAnimesToday?: ScheduledAnimeToday[]; // Added for LType
}

// A-Z List
export interface AZListAnime extends DetailedAnime {}

export interface AZListData {
  sortOption: string;
  animes: AZListAnime[];
  totalPages: number;
  currentPage: number;
  hasNextPage: boolean;
}

// Qtip Info
export interface QtipAnimeInfo {
  id: string;
  name: string;
  malscore: string;
  quality: string;
  episodes: EpisodesInfo;
  type: string;
  description: string;
  jname: string;
  synonyms: string;
  aired: string;
  status: string;
  genres: string[];
  isAdult?: boolean; // Added for 18+ content
}

export interface QtipData {
  anime: QtipAnimeInfo;
}

// Anime About Info
export interface AnimeInfoStats {
  rating: string;
  quality: string;
  episodes: EpisodesInfo;
  type: string;
  duration: string;
}

export interface PromotionalVideo {
  title?: string;
  source?: string;
  thumbnail?: string;
}

export interface CharacterVoiceActorPair {
  character: {
    id: string;
    poster: string;
    name: string;
    cast: string;
  };
  voiceActor: {
    id: string;
    poster: string;
    name: string;
    cast: string;
  };
}

export interface AnimeInfo extends BaseAnime { // Ensure AnimeInfo also conforms to BaseAnime if poster/name/id is directly on it
  description: string;
  stats: AnimeInfoStats;
  promotionalVideos: PromotionalVideo[];
  characterVoiceActor: CharacterVoiceActorPair[];
  jname?: string; 
  ltypeDataId?: number; // Added for LType numeric ID for megaplay.buzz embed
}


export interface MoreAnimeInfo {
  aired: string;
  genres: string[];
  status: string;
  studios: string;
  duration: string;
  [key: string]: any; // For other dynamic properties
}

export interface AnimeDetail {
  info: AnimeInfo;
  moreInfo: MoreAnimeInfo;
}

export interface Season extends BaseAnime { // Seasons are also anime-like items
  title: string; // Specific to season
  isCurrent: boolean;
}


export interface AnimeAboutData {
  anime: AnimeDetail;
  mostPopularAnimes: BaseAnime[];
  recommendedAnimes: DetailedAnime[];
  relatedAnimes: DetailedAnime[];
  seasons: Season[];
}

// Search Results
export interface SearchAnime extends DetailedAnime {}

export interface SearchFilters {
  [filter_name: string]: string[];
}

export interface SearchData {
  animes: SearchAnime[];
  mostPopularAnimes: BaseAnime[];
  currentPage: number;
  totalPages: number;
  hasNextPage: boolean;
  searchQuery: string;
  searchFilters: SearchFilters;
}

// Search Suggestions
export interface SuggestionAnime {
  id: string;
  name: string;
  poster: string;
  jname: string;
  moreInfo: string[];
  isAdult?: boolean; // Added for 18+ content
}

export interface SuggestionData {
  suggestions: SuggestionAnime[];
}

// Producer Animes
export interface ProducerData {
  producerName: string;
  animes: DetailedAnime[];
  top10Animes: {
    today: RankedAnime[];
    week: RankedAnime[];
    month: RankedAnime[];
  };
  topAiringAnimes: BaseAnime[];
  currentPage: number;
  totalPages: number;
  hasNextPage: boolean;
}

// Genre Animes
export interface GenreData {
  genreName: string;
  animes: DetailedAnime[];
  genres: string[];
  topAiringAnimes: BaseAnime[];
  currentPage: number;
  totalPages: number;
  hasNextPage: boolean;
}

// Category Animes
export interface CategoryData {
  category: string;
  animes: DetailedAnime[];
  genres: string[];
  top10Animes?: {
    today: RankedAnime[];
    week: RankedAnime[];
    month: RankedAnime[];
  };
  currentPage: number;
  totalPages: number;
  hasNextPage: boolean;
}

// Estimated Schedules
export interface ScheduledAnime {
  id: string;
  time: string;
  name: string;
  jname: string;
  airingTimestamp: number;
  secondsUntilAiring: number;
  isAdult?: boolean; // Added for 18+ content
}

export interface ScheduleData {
  scheduledAnimes: ScheduledAnime[];
}

// Anime Episodes
export interface Episode {
  number: number;
  title: string;
  episodeId: string; // For HiAnime: episode_id. For LType: constructed as `${ltypeAnimeId}$${ltypeEpisodeDataId}`
  isFiller: boolean;
  ltypeNumericEpisodeId?: number; // Specific numeric ID for LType episodes (ep.data_id or parsed from ep.id)
}

export interface EpisodesData {
  totalEpisodes: number;
  episodes: Episode[];
}

// Next Episode Schedule
export interface NextEpisodeScheduleData {
  airingISOTimestamp: string | null;
  airingTimestamp: number | null;
  secondsUntilAiring: number | null;
}

// Episode Servers
export interface Server {
  serverId: number | string; // Can be string for LType if serverName is used as ID
  serverName: string;
}

export interface EpisodeServersData {
  episodeId: string; // The original episodeId passed to fetch servers
  episodeNo: number;
  sub: Server[];
  dub: Server[];
  raw: Server[];
}

// Episode Streaming Links
export interface Source {
  url: string;
  isM3U8: boolean;
  quality?: string; // e.g., "1080p", "720p", "default", "auto"
}

export interface Subtitle {
  lang: string; // e.g., "English", "Spanish"
  url: string;
  kind?: 'subtitles' | 'captions'; // Optional: usually 'subtitles'
}

export interface ApiTrack { 
  file: string;
  lang: string;
  kind: 'captions' | 'subtitles' | string; 
  default?: boolean;
}

export interface IntroTimestamp {
  start: number;
  end: number;
}

export interface EpisodeSourcesData {
  headers: {
    Referer?: string; 
    "User-Agent": string;
    [key: string]: string;
  };
  sources: Source[];
  subtitles: Subtitle[]; 
  tracks?: ApiTrack[];
  intro?: IntroTimestamp;
  outro?: IntroTimestamp;
  anilistID: number | null;
  malID: number | null;
}

// General API Response Wrapper for HiAnime
export interface ApiResponse<T> {
  success: boolean;
  data: T;
  message?: string;
}

// General API Response Wrapper for LTypeAnime
export interface LTypeApiResponse<T> {
  success: boolean;
  results: T;
  message?: string; 
}


// App Settings
export type WallpaperType = 'none' | 'particles' | 'stars' | 'snow';
export type ApiProviderType = 'hianime' | 'ltype';

export interface AppSettings {
  wallpaper: WallpaperType;
  theme: string; 
  selectedApi: ApiProviderType;
  apiSelectionCompleted: boolean; 
}

// Custom Video Player Types
export type SubtitleFontFamily = 'Poppins' | 'Arial' | 'Verdana' | 'Times New Roman' | 'Courier New' | 'Comic Sans MS';
export type SubtitleFontSize = 'Small' | 'Medium' | 'Large' | 'X-Large';
export type SubtitleFontColor = '#FFFFFF' | '#FFFF00' | '#00FFFF' | '#00FF00' | '#FF69B4'; // White, Yellow, Cyan, Green, Pink
export type SubtitleTextShadowStyle = 'none' | 'drop' | 'outlineDark' | 'outlineLight' | 'enhancedDark' | 'glowPurple';
export type VideoAspectRatio = 'contain' | 'cover' | 'fill';

export interface SubtitleSettings {
  enabled: boolean;
  fontFamily: SubtitleFontFamily;
  fontSize: SubtitleFontSize; 
  fontColor: SubtitleFontColor;
  textShadowStyle: SubtitleTextShadowStyle;
  backgroundOpacity: number; 
  activeTrackUrl: string | null; 
}

export interface VideoPlayerSettings extends SubtitleSettings { 
  autoPlayNext: boolean;
  autoSkipIntro: boolean;
  aspectRatio: VideoAspectRatio;
}


export interface VideoQuality {
  url: string;
  qualityLabel: string; 
  levelIndex?: number; 
}

// Watchlist Types
export type WatchlistStatus = 'plan_to_watch' | 'watching' | 'completed' | 'on_hold' | 'dropped';

export const WATCHLIST_STATUSES: WatchlistStatus[] = ['plan_to_watch', 'watching', 'completed', 'on_hold', 'dropped'];

export const UNCATEGORIZED_STATUS_KEY = 'uncategorized' as const;
export type DisplayWatchlistCategory = WatchlistStatus | typeof UNCATEGORIZED_STATUS_KEY;
export const WATCHLIST_DISPLAY_CATEGORIES: DisplayWatchlistCategory[] = [...WATCHLIST_STATUSES, UNCATEGORIZED_STATUS_KEY];


export const getStatusDisplayName = (status: DisplayWatchlistCategory): string => {
  switch (status) {
    case 'plan_to_watch': return 'Plan to Watch';
    case 'watching': return 'Watching';
    case 'completed': return 'Completed';
    case 'on_hold': return 'On-Hold';
    case 'dropped': return 'Dropped';
    case 'uncategorized': return 'Uncategorized';
    default: return 'Unknown Status';
  }
};


export interface AnimeWatchlistActionItem {
  id: string;
  name: string; 
  poster: string; 
  isAdult?: boolean; 
}

export interface SupabaseWatchlistItem {
  anime_id: string;
  status: WatchlistStatus; 
}

// Supabase Auth Types
export interface SupabaseUser {
  id: string;
  email?: string;
}

export interface SupabaseAuthUser {
  id: string;
  aud: string;
  role?: string;
  email?: string;
  email_confirmed_at?: string;
  phone?: string;
  phone_confirmed_at?: string;
  confirmed_at?: string; 
  last_sign_in_at?: string;
  app_metadata?: {
    provider?: string;
    providers?: string[];
    [key: string]: any;
  };
  user_metadata?: {
    [key: string]: any;
  };
  identities?: any[]; 
  created_at?: string;
  updated_at?: string;
  is_anonymous?: boolean;
}

export interface SupabaseSession {
  access_token: string;
  token_type: string;
  expires_in?: number;
  expires_at?: number;
  refresh_token?: string;
  user: SupabaseAuthUser; 
}

export interface UserProfile {
  id: string; 
  username: string | null;
  avatarurla?: string | null;
  bannerurla?: string | null;
  watchlist_is_public?: boolean;
  email_is_public?: boolean;
  tags?: Tag[]; 
  watchStatistics?: UserWatchStatistics;
}

export interface PublicUserProfileInfo { 
  id: string;
  username: string | null;
  avatarurla?: string | null;
  bannerurla?: string | null;
  watchlist_is_public?: boolean; 
  email_is_public?: boolean; 
  tags?: Tag[];
  watchStatistics?: UserWatchStatistics; 
}


// Auth Context Data Type
export interface AuthContextData {
  supabase: any | null; 
  currentUser: SupabaseUser | null; 
  userProfile: UserProfile | null;
  isLoading: boolean;
  error: Error | null;
  signIn: (email?: string, password?: string) => Promise<{ error: any | null }>;
  signUp: (email?: string, password?: string) => Promise<{ data: { user: SupabaseAuthUser | null; session: SupabaseSession | null; }; error: any | null; }>;
  signOut: () => Promise<void>;
  updateUsername: (newUsername: string) => Promise<{ error: any | null; data?: UserProfile | null }>;
  updateUserPassword: (newPassword: string) => Promise<{ error: any | null }>;
  updateUserEmail: (newEmail: string) => Promise<{ error: any | null }>;
  resendConfirmationEmail: (email: string) => Promise<{ error: any | null }>;
  updateUserAvatar: (avatarFile: File) => Promise<{ error: any | null; data?: UserProfile | null }>;
  updateUserBanner: (bannerFile: File) => Promise<{ error: any | null; data?: UserProfile | null }>;
  updateProfilePrivacySettings: (settings: { watchlist_is_public?: boolean; email_is_public?: boolean }) => Promise<{ error: any | null; data?: UserProfile | null }>;
  fetchUserTags: (userId: string) => Promise<Tag[]>;
  fetchUserWatchStatistics: (userId: string) => Promise<UserWatchStatistics | null>;
}

// Notification Types
export type NotificationType = 'success' | 'error' | 'info' | 'warning';

export interface NotificationMessage {
  id: string;
  message: string;
  type: NotificationType;
  duration?: number;
}

// Anime Reviews / Comments
export interface AnimeReviewSubmission {
  user_id: string;
  anime_id: string;
  rating: number | null; 
  comment_text: string | null; 
}

export interface AnimeReview {
  id: number; 
  created_at: string; 
  user_id: string;
  anime_id: string;
  rating: number | null;
  comment_text: string | null;
  reviewerUsername?: string; 
}

// Watch2Gether Types
export interface W2GRoomMember {
  id: string; 
  displayName: string;
  isHost: boolean;
}

export interface W2GChatMessage {
  id: string; 
  userId: string; 
  userDisplayName: string;
  text: string;
  timestamp: number; 
}

export type W2GVideoEventType = 
  | 'PLAY' 
  | 'PAUSE' 
  | 'SEEK' 
  | 'REQUEST_STATE' 
  | 'SYNC_STATE'
  | 'SOURCE_UPDATE'; 

export interface W2GVideoEvent {
  type: W2GVideoEventType;
  currentTime?: number;
  isPlaying?: boolean;
  senderId?: string; 
  
  episodeId?: string; 
  serverName?: string;
  serverCategory?: 'sub' | 'dub' | 'raw';

  playbackRate?: number;
  hlsLevel?: number; 
  activeSubtitleTrackUrl?: string | null;
  subtitlesEnabled?: boolean;

  currentSourceDetails?: {
    episodeId: string;
    serverName: string;
    serverCategory: 'sub' | 'dub' | 'raw';
  };
}

// External Watchlist Import Types
export type ExternalWatchlistStatus = 
  | 'CURRENT' 
  | 'PLANNING' 
  | 'COMPLETED' 
  | 'DROPPED' 
  | 'PAUSED' 
  | 'REPEATING'
  | '1' | 1 
  | '2' | 2 
  | '3' | 3 
  | '4' | 4 
  | '6' | 6 
  | string; 

export interface ExternalWatchlistItem {
  title: string;
  status: ExternalWatchlistStatus;
  score?: number;
  progress?: number; 
}

// Watched Episodes (Supabase user_anime_progress & user_watched_episodes)
export interface UserAnimeProgress {
  user_id: string;
  anime_id: string;
  total_episodes: number;
  anime_name: string;
  anime_poster: string;
  last_watched_timestamp: string; 
  last_watched_episode_number: number | null;
  last_watched_episode_current_time: number | null; 
}

export interface UserWatchedEpisode {
  user_id: string;
  anime_id: string;
  episode_number: number;
  watched_at: string; 
}


export interface WatchedEpisodeInfo { 
  watchedEpisodeNumbers: number[]; 
  totalEpisodes: number;
  poster: string;
  name: string;
  lastWatchedTimestamp: number; 
  lastWatchedEpisodeNumber?: number;
  nextEpisodeToWatch?: number;
  resumeTimestamp?: number; 
}

export interface ContinueWatchingItem extends WatchedEpisodeInfo {
  animeId: string;
  progress: number; 
}

// Trace.moe API Types
export interface TraceMoeAnilistInfo {
  id: number;
  idMal: number | null;
  title: {
    native?: string | null;
    romaji?: string | null;
    english?: string | null;
  };
  synonyms: string[];
  isAdult: boolean;
}

export interface TraceMoeResult {
  anilist: TraceMoeAnilistInfo; 
  filename: string;
  episode: number | null;
  from: number;
  to: number;
  similarity: number;
  video: string;
  image: string;
}

export interface TraceMoeResponse {
  frameCount: number;
  error: string;
  result: TraceMoeResult[];
}

// User Tags/Achievements (Supabase table: `tags`)
export type TagRarity = 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary';

export interface Tag {
  id: string; // UUID
  name: string;
  description: string;
  rarity: TagRarity;
  icon_svg?: string | null; 
  created_at: string;
}

// User Unlocked Tags (Supabase table: `user_tags`)
export interface UserTag {
  id: string; // UUID for the user_tag record itself
  user_id: string; // UUID FK to auth.users
  tag_id: string; // UUID FK to tags
  unlocked_at: string; // TIMESTAMPTZ
  tag?: Tag; // For joining
}

export interface UserWatchStatistics {
  user_id: string;
  total_watch_time_seconds: number;
  last_updated_at: string;
}

// Community Tagging System Types
export type CommunityTagType = 'descriptive' | 'warning';

export interface CommunityTag {
  id: string; // UUID
  name: string; // e.g., "Plot Twist", "Graphic Violence"
  description: string | null;
  type: CommunityTagType; // 'descriptive' or 'warning'
  is_spoiler: boolean;
  created_by: string | null; // user_id of creator, null if system-defined
  created_at: string;
}

export interface AppliedCommunityTag extends CommunityTag {
  applied_count: number; // How many users applied this tag to a specific anime
}


// LType Specific Types (raw from docs, to be mapped)
export interface LTypeTvInfo {
  showType?: string;
  duration?: string;
  releaseDate?: string; 
  quality?: string;     
  // Spotlight has 'episodeInfo', others might have direct sub/dub/eps
  episodeInfo?: { sub?: number; dub?: number; eps?: number }; 
  sub?: number; 
  dub?: number; 
  eps?: number; 
}

export interface LTypeSpotlightItem {
  id: string;
  data_id: number;
  poster: string;
  title: string;
  japanese_title?: string;
  description: string;
  tvInfo: LTypeTvInfo;
  adultContent?: boolean;
}

export interface LTypeTrendingItem {
  id: string;
  data_id: number;
  number: number; 
  poster: string;
  title: string;
  japanese_title?: string;
  adultContent?: boolean; 
}

export interface LTypeScheduledAnimeTodayItem {
    id: string;
    data_id: number;
    title: string;
    japanese_title?: string;
    releaseDate: string; 
    time: string; 
    episode_no: number;
    adultContent?: boolean; 
}

export interface LTypeHomePageResults {
  spotlights: LTypeSpotlightItem[];
  trending: LTypeTrendingItem[];
  today: { schedule: LTypeScheduledAnimeTodayItem[] };
  topAiring: LTypeSpotlightItem[]; 
  mostPopular: LTypeSpotlightItem[];
  mostFavorite: LTypeSpotlightItem[];
  latestCompleted: LTypeSpotlightItem[];
  latestEpisode: LTypeSpotlightItem[];
  genres: string[];
}

export interface LTypeTopTenAnimeItem {
    id: string;
    data_id: number;
    number: number; 
    name: string;
    poster: string;
    tvInfo: LTypeTvInfo;
    adultContent?: boolean; 
}
export interface LTypeTopTenResults {
    topTen: { 
        today: LTypeTopTenAnimeItem[];
        week: LTypeTopTenAnimeItem[];
        month: LTypeTopTenAnimeItem[];
    }
}

export interface LTypeCategoryItem {
    id: string;
    data_id: number;
    poster: string;
    title: string;
    japanese_title?: string;
    description?: string; 
    tvInfo: LTypeTvInfo;
    adultContent?: boolean;
}
export interface LTypeCategoryResults {
    totalPages: number;
    data: LTypeCategoryItem[];
}

// LType API Types for Episode Sources
export interface LTypeEpisodeItem {
  episode_no: number;
  id: string; 
  data_id?: number; 
  title: string;
  japanese_title?: string;
  filler?: boolean; 
}

export interface LTypeEpisodesResults {
  totalEpisodes: number;
  episodes: LTypeEpisodeItem[];
}

export interface LTypeServerItem {
  type: 'sub' | 'dub'; 
  data_id: number; 
  server_id: number; 
  serverName: string; 
}

// LType API Track (raw from their API for /stream endpoint)
export interface LTypeApiTrack { 
  file: string;
  label: string; // LType uses 'label'
  kind: 'captions' | 'subtitles' | string; 
  default?: boolean;
}

export interface LTypeStreamLink {
  id: number; 
  type: 'sub' | 'dub' | string; 
  link: {
    file: string; 
    type: 'hls' | 'mp4' | string; 
  };
  tracks: LTypeApiTrack[]; // Use LType specific track type here
  intro?: { start: number; end: number };
  outro?: { start: number; end: number };
  server: string; 
}

export interface LTypeStreamServerInfo { 
    type: 'sub' | 'dub' | string;
    data_id: number;
    server_id: number;
    server_name: string; 
}

export interface LTypeStreamResults {
  streamingLink: LTypeStreamLink[]; 
  servers: LTypeStreamServerInfo[]; 
}


// LType Anime Info types
export interface LTypeAnimeInfoData {
  adultContent: boolean;
  id: string; 
  data_id: number;
  title: string;
  japanese_title?: string;
  poster: string;
  showType: string;
  animeInfo: { 
    Overview?: string;
    Japanese?: string;
    Synonyms?: string;
    Aired?: string;
    Premiered?: string;
    Duration?: string;
    Status?: string;
    "MAL Score"?: string;
    Genres?: { name: string; url: string }[]; 
    Studios?: string;
    Producers?: { name: string; url: string }[]; 
  };
}

export interface LTypeSeasonItem {
  id: string;
  data_number: number;
  data_id: number;
  season: string;
  title: string;
  japanese_title?: string;
  season_poster: string;
}

export interface LTypeAnimeDetailResults {
  data: LTypeAnimeInfoData;
  seasons: LTypeSeasonItem[];
  related_data?: any[]; 
  recommended_data?: any[]; 
}