Feature Suggestion: Add Support for Using M3U Files Locally or via URL

[TheDeatCrusher]

This feature would enhance TVS Simulator 99 by allowing users to load and stream M3U playlist files from either their local device storage or an external URL. By integrating this capability with the existing static web server and YAML configuration, users could easily manage and customize their playlists. This flexibility would improve content accessibility, enabling users to choose between local or online sources based on their preferences and needs for seamless media playback within the simulator."

[itsdarklikehell]

I've been checking in to this also.
I have been working on my own bash implementation to convert the iptv-org .m3u playlists to a .yml template, but it's not done yet.

[itsdarklikehell]

a bash version of a script that does this:

usage example:
bash ./m3u2tvs.sh https://iptv-org.github.io/iptv/index.m3u

#!/bin/bash

# Script: M3U to TV Simulator '99 Converter
# Description: Converts M3U playlists into TV Simulator '99 compatible YAML format
# Author: Community
# Version: 1.0

# Initialize terminal size
eval 'resize' >/dev/null

# Color definitions for output
declare -r RED='\033[0;31m'
declare -r GREEN='\033[0;32m'
declare -r YELLOW='\033[1;33m'
declare -r BLUE='\033[0;34m'
declare -r CYAN='\033[0;36m'
declare -r NC='\033[0m' # No Color
declare -r BOLD='\033[1m'

# Performance tuning parameters
BUFFER_SIZE=5000             # Number of lines to buffer before writing
PROGRESS_UPDATE_FREQUENCY=50 # Update progress every N items
PARALLEL_JOBS=$(nproc)       # Number of parallel jobs (CPU cores)

# filepath: /media/rizzo/DATA/retronas/tvs/m3u2tvs.sh
eval 'resize' >/dev/null

# Check for dialog
if ! command -v dialog >/dev/null 2>&1; then
  echo "Please install dialog to run this script"
  echo "Ubuntu/Debian: sudo apt install dialog"
  echo "Fedora: sudo dnf install dialog"
  exit 1
fi

# Dialog configurations
TITLE="TV Simulator '99 M3U Importer"
BACKTITLE="TV Simulator '99 Channel Configuration Tool"
WIDTH=60
HEIGHT=20

# Show welcome screen
dialog --title "$TITLE" \
  --backtitle "$BACKTITLE" \
  --msgbox "Welcome to TV Simulator '99 M3U Importer\n\nThis tool will help you import M3U playlists into TV Simulator '99 format." \
  $HEIGHT $WIDTH

# Check if M3U URL is provided or ask for it
if [ -z "$1" ]; then
  M3U_URL=$(dialog --title "$TITLE" \
    --backtitle "$BACKTITLE" \
    --inputbox "Enter the M3U URL:" \
    $HEIGHT $WIDTH \
    "https://iptv-org.github.io/iptv/index.m3u" \
    2>&1 >/dev/tty)

  if [ $? -ne 0 ]; then
    dialog --title "$TITLE" --msgbox "Operation cancelled by user" $LINES $COLUMNS
    clear
    exit 1
  fi
else
  M3U_URL="$1"
fi

# Add directory initialization function
init_directories() {
  local base_dir="channels"
  local dirs=(
    "$base_dir"
    "$base_dir/categories"
    "$base_dir/language"
    "$base_dir/region"
    "$base_dir/country"
  )

  for dir in "${dirs[@]}"; do
    if ! mkdir -p "$dir"; then
      log_error "Failed to create directory: $dir"
      exit 1
    fi
    log_info "Created directory: $dir"
  done
}

# Ask for output file if not provided
if [ -z "$2" ]; then
  DEFAULT_OUTPUT="channels/index.tvs.yml"

  # Initialize directory structure
  init_directories

  OUTPUT_FILE=$(dialog --title "$TITLE" \
    --backtitle "$BACKTITLE" \
    --inputbox "Enter output filename:" \
    $HEIGHT $WIDTH \
    "$DEFAULT_OUTPUT" \
    2>&1 >/dev/tty)

  if [ $? -ne 0 ]; then
    dialog --title "$TITLE" --msgbox "Operation cancelled by user" $LINES $COLUMNS
    clear
    exit 1
  fi
else
  # Ensure provided path is in channels directory
  OUTPUT_FILE="channels/$(basename "$2")"
  init_directories
fi

TEMP_M3U="/tmp/$(basename "$M3U_URL")"

# Create or verify output file
if [ -f "$OUTPUT_FILE" ]; then
  LAST_CHANNEL=$(grep "number:" "$OUTPUT_FILE" | awk '{print $3}' | sort -n | tail -n 1)
  current_channel=$((LAST_CHANNEL + 1))
else
  current_channel=1
  # Create base config
  cat >"$OUTPUT_FILE" <<EOL
# Generated from $M3U_URL
baseDirectory: .
applicationTitle: TV Simulator '99 (Public Beta)
autoScale: true
bezel: cylindrical
blur: false
border: placeholders/border.png
defaultChannel: 1
noise: 0.15
scanlines: true
shadowMask: false
startUnmuted: true
osd:
  theme: digital
  primaryColor: "#0000FF"
  accentColor: "#000000"
channels:
EOL
fi

# Define categories array in alphabetical order
categories=(
  "Animation"
  "Auto"
  "Business"
  "Classic"
  "Comedy"
  "Cooking"
  "Culture"
  "Documentary"
  "Education"
  "Entertainment"
  "Family"
  "General"
  "Kids"
  "Legislative"
  "Lifestyle"
  "Movies"
  "Music"
  "News"
  "Outdoor"
  "Relax"
  "Religious"
  "Science"
  "Series"
  "Shop"
  "Sports"
  "Travel"
  "Weather"
  "XXX"
  "Undefined"
)

# Add new function to write category config
write_category_config() {
  local category=$1
  local safe_category
  safe_category=$(echo "$category" | tr ' /' '_')
  local category_file="channels/categories/${safe_category}.tvs.yml"

  # Base config is same, just ensure parent directory exists
  if [ ! -d "channels/categories" ]; then
    mkdir -p "channels/categories"
  fi

  # Create base config for category
  cat >"$category_file" <<EOL
# Generated from $M3U_URL - Category: $category
baseDirectory: .
applicationTitle: TV Simulator '99 (Public Beta) - $category
autoScale: true
bezel: cylindrical
blur: false
border: placeholders/border.png
defaultChannel: 1
noise: 0.15
scanlines: true
shadowMask: false
startUnmuted: true
osd:
  theme: digital
  primaryColor: "#0000FF"
  accentColor: "#000000"
channels:
EOL
  echo "$category_file"
}

# Add organization config function
write_organization_config() {
  local type=$1    # Type of organization (e.g., "language", "region", "country")
  local value=$2   # actual value (e.g., "English", "Europe", "USA")
  local safe_value # actual value (e.g., "English", "Europe", "USA")
  safe_value=$(echo "$value" | tr ' /' '_')
  local output_file="channels/${type}/${safe_value}.tvs.yml"

  # Ensure parent directory exists
  if [ ! -d "channels/${type}" ]; then
    mkdir -p "channels/${type}"
  fi

  # Create base config
  cat >"$output_file" <<EOL
# Generated from $M3U_URL - ${type}: $value
# ...existing config...
EOL
  echo "$output_file"
}

# Simplified process_category function
process_category() {
  local category=$1
  local start_num=$2
  local channel_count=0
  local current_url=""
  local total_entries
  total_entries=$(grep -c "group-title=\"$category\"" "$TEMP_M3U")
  local progress=$3
  local step=$4

  # Create category config file
  local category_file
  category_file=$(write_category_config "$category")

  while IFS= read -r line; do
    if [[ $line == "#EXTINF:"* ]]; then
      channel_category=$(echo "$line" | grep -oP '(?<=group-title=")[^"]*' || echo "Undefined")
      if [[ $channel_category == "$category" ]]; then
        # Extract channel info
        channel_name=$(echo "$line" | grep -oP '(?<=group-title=")[^"]*' || echo "Channel $start_num")
        channel_logo=$(echo "$line" | grep -oP '(?<=tvg-logo=")[^"]*' || echo "placeholders/example-program.gif")
        channel_id=$(echo "$line" | grep -oP '(?<=tvg-id=")[^"]*' || echo "CH$start_num")
        country=$(echo "$line" | grep -oP '(?<=tvg-country=")[^"]*' || echo "Unknown")
        language=$(echo "$line" | grep -oP '(?<=tvg-language=")[^"]*' || echo "Unknown")

        description="\"Channel: ${channel_name}\nCategory: ${category}\nCountry: ${country}\nLanguage: ${language}\""

        # Update overall progress
        echo "$progress"
        echo "XXX"
        echo "Processing category ($((processed + 1))/$total_categories): $category"
        echo "XXX"
      fi
    elif [[ $line == "http"* ]] && [[ $channel_category == "$category" ]]; then
      current_url="$line"
      # Create channel entry in both files
      cat >>"$OUTPUT_FILE" <<EOL
  - number: $start_num
    abbr: ${channel_id:0:5}
    name: ${channel_name}
    title: ${channel_name}
    description: ${description}
    loop:
      - image: ${channel_logo}
        duration: 1
      - video:
          provider: hls
          src: ${current_url}
          hlsBugFix: true
      - image: ${channel_logo}
        duration: 1
EOL

      # Add to category-specific file with channel number starting from 1
      cat >>"$category_file" <<EOL
  - number: $((channel_count + 1))
    abbr: ${channel_id:0:5}
    name: ${channel_name}
    title: ${channel_name}
    description: ${description}
    loop:
      - image: ${channel_logo}
        duration: 1
      - video:
          provider: hls
          src: ${current_url}
          hlsBugFix: true
      - image: ${channel_logo}
        duration: 1
EOL

      ((start_num++))
      ((channel_count++))
      # Calculate new progress
      local new_progress=$((progress + (channel_count * step / total_entries)))
      echo $new_progress
    fi
  done <"$TEMP_M3U"

  echo "$channel_count"
  return 0
}

# Main processing with overall progress
total_categories=${#categories[@]}
processed=0
progress=0
step=$((100 / total_categories))

(
  # Download phase - 5%
  echo 0
  echo "XXX"
  echo "Downloading playlist..."
  echo "XXX"

  wget -q "$M3U_URL" -O "$TEMP_M3U" || {
    dialog --title "$TITLE" --msgbox "Failed to download M3U file!" $LINES $COLUMNS
    clear
    exit 1
  }

  echo 5
  echo "XXX"
  echo "Starting processing..."
  echo "XXX"

  # Process categories - 95% remaining
  progress=5
  category_step=$((95 / total_categories))

  for category in "${categories[@]}"; do
    process_category "$category" "$current_channel" "$progress" "$category_step"
    channels_added=$?
    current_channel=$((current_channel + channels_added + 1))
    progress=$((progress + category_step))
    ((processed++))
  done

  # Ensure we hit 100%
  echo 100
  echo "XXX"
  echo "Processing complete!"
  echo "XXX"
  sleep 1
) | dialog --title "$TITLE" \
  --backtitle "$BACKTITLE" \
  --gauge "Starting import process..." \
  $LINES $COLUMNS $((LINES - 8))

# Show completion dialog
SUMMARY="Processing complete!\n\n"
SUMMARY+="Total categories: $total_categories\n"
SUMMARY+="Channels: $((current_channel - 1))\n"
SUMMARY+="Main output: $OUTPUT_FILE\n"
SUMMARY+="Channel configs created in: ./channels/"

dialog --title "$TITLE" \
  --backtitle "$BACKTITLE" \
  --msgbox "$SUMMARY" \
  $HEIGHT $WIDTH

# Cleanup
rm "$TEMP_M3U"
clear

echo "[INFO] Created $OUTPUT_FILE with $((current_channel - 1)) channels"

# Add performance and progress configurations at the top
declare -r BUFFER_SIZE=5000
declare -r PROGRESS_UPDATE_FREQUENCY=50
declare -r PARALLEL_JOBS
PARALLEL_JOBS=$(nproc)
declare -r PROGRESS_FILE="/tmp/m3u2tvs_progress"

# Add progress management functions
init_progress() {
  echo "0" >"$PROGRESS_FILE"
}

update_progress() {
  local new_progress=$1
  echo "$new_progress" >"$PROGRESS_FILE"
}

get_progress() {
  cat "$PROGRESS_FILE" 2>/dev/null || echo "0"
}

# Update cleanup to include progress file
cleanup() {
  rm -f "$TEMP_M3U" "$BUFFER_FILE" "$PROGRESS_FILE"
  [ $? -eq 0 ] && log_success "Cleanup completed"
}

# Add optimized metadata extraction
extract_metadata() {
  awk -F'"' '
    /^#EXTINF:/ {
        for(i=1;i<=NF;i++) {
            if($i~/tvg-id=/) id=$(i+1)
            if($i~/tvg-logo=/) logo=$(i+1)
            if($i~/group-title=/) category=$(i+1)
            if($i~/tvg-country=/) country=$(i+1)
            if($i~/tvg-language=/) language=$(i+1)
        }
        print id"\t"logo"\t"category"\t"country"\t"language
    }'
}

# Add buffer management
BUFFER_FILE=$(mktemp)
buffer_write() {
  local file=$1
  local content=$2
  echo "$content" >>"$BUFFER_FILE"
  if [ "$(wc -l <"$BUFFER_FILE")" -ge "$BUFFER_SIZE" ]; then
    cat "$BUFFER_FILE" >>"$file"
    true >"$BUFFER_FILE"
  fi
}

buffer_flush() {
  local file=$1
  [ -s "$BUFFER_FILE" ] && cat "$BUFFER_FILE" >>"$file"
  true >"$BUFFER_FILE"
}

# Update process_category for better performance
process_category() {
  local category=$1
  local start_num=$2
  local progress=$3
  local step=$4
  local channel_count=0

  local category_file
  category_file=$(write_category_config "$category")

  # Pre-filter entries for this category and process in chunks
  grep -A1 "group-title=\"$category\"" "$TEMP_M3U" | while read -r line; do
    if [[ $line == "#EXTINF:"* ]]; then
      # Use optimized metadata extraction
      IFS=$'\t' read -r id logo category country language <<<"$(echo "$line" | extract_metadata)"
      channel_name="${category:-Channel $start_num}"
      description="\"Channel: ${channel_name}\nCategory: ${category}\nCountry: ${country}\nLanguage: ${language}\""
    elif [[ $line == "http"* ]]; then
      # Buffer writes instead of direct file access
      buffer_write "$OUTPUT_FILE" "$(generate_channel_entry "$start_num" "$id" "$channel_name" "$description" "$logo" "$line")"
      buffer_write "$category_file" "$(generate_channel_entry "$((channel_count + 1))" "$id" "$channel_name" "$description" "$logo" "$line")"

      ((start_num++))
      ((channel_count++))

      # Update progress less frequently
      if ((channel_count % PROGRESS_UPDATE_FREQUENCY == 0)); then
        echo $((progress + (channel_count * step / total_entries)))
      fi
    fi
  done

  # Flush any remaining buffered content
  buffer_flush "$OUTPUT_FILE"
  buffer_flush "$category_file"

  echo "$channel_count"
  return 0
}

# Add parallel processing support
process_categories_parallel() {
  if command -v parallel >/dev/null 2>&1; then
    export -f process_category extract_metadata buffer_write buffer_flush
    export BUFFER_SIZE PROGRESS_UPDATE_FREQUENCY
    printf '%s\n' "${categories[@]}" | parallel --will-cite -j "$PARALLEL_JOBS" process_category {} "$current_channel" "$progress" "$category_step"
  else
    # Fallback to sequential processing
    for category in "${categories[@]}"; do
      process_category "$category" "$current_channel" "$progress" "$category_step"
    done
  fi
}

# Update main processing section
(
  init_progress

  # Download phase
  echo 0
  echo "XXX"
  echo "Downloading playlist..."
  echo "XXX"

  wget -q "$M3U_URL" -O "$TEMP_M3U" || {
    log_error "Failed to download M3U file!"
    exit 1
  }

  # Pre-process M3U file
  log_info "Pre-processing playlist..."
  grep -E '^#EXTINF:|^http' "$TEMP_M3U" >"${TEMP_M3U}.processed"
  mv "${TEMP_M3U}.processed" "$TEMP_M3U"

  # Process categories with smoother progress updates
  total_entries=$(grep -c "^#EXTINF:" "$TEMP_M3U")
  export progress_step=$((95 / total_entries))

  process_categories_parallel

  # Ensure we hit 100% smoothly
  for i in {95..100}; do
    echo "$i"
    echo "XXX"
    echo "Finalizing..."
    echo "XXX"
    sleep 0.05
  done
) | dialog --title "$TITLE" \
  --backtitle "$BACKTITLE" \
  --gauge "Starting import process..." \
  $LINES $COLUMNS $((LINES - 8))

[itsdarklikehell]

a python version of a script that does this:

usage:
python3 ./m3u2tvs.py https://iptv-org.github.io/iptv/index.m3u

#!/usr/bin/env python3

"""
M3U to TV Simulator '99 Converter
--------------------------------
Converts M3U playlists into TV Simulator '99 compatible YAML format
with support for categorization and organization by language, region, and country.

This script provides both CLI and interactive TUI interfaces for processing
M3U playlists into multiple YAML configurations organized by various attributes.
"""

import os
import sys
import re
import yaml
import urllib.request
import asyncio
import aiohttp
from pathlib import Path
from typing import Dict, List, Optional
from dataclasses import dataclass
from concurrent.futures import ThreadPoolExecutor
import curses
from curses.textpad import Textbox, rectangle

class Config:
    """Configuration class for TV Simulator '99 output files"""
    def __init__(self):
        self.title = "My TV Station"
        self.description = "A collection of TV channels"
        self.icon = "icon.png"

@dataclass
class Channel:
    """
    Represents a TV channel with all its attributes and metadata.
    
    Properties:
        safe_language: Sanitized language name for filenames
        safe_country: Sanitized country name for filenames
        safe_category: Sanitized category name for filenames
        region: Determined region based on country code
        safe_region: Sanitized region name for filenames
    """
    number: int
    abbr: str
    name: str
    title: str
    description: str
    logo: str
    url: str
    category: str
    country: str
    language: str
    
    def safe_value(self, value: str) -> str:
        """Convert value to safe filename"""
        if not value or value == "Unknown":
            return "unknown"
        return value.replace('/', '_').replace(' ', '_').lower()
    
    @property
    def safe_language(self) -> str:
        return self.safe_value(self.language)
    
    @property
    def safe_country(self) -> str:
        return self.safe_value(self.country)
    
    @property
    def safe_category(self) -> str:
        return self.safe_value(self.category)
    
    @property
    def region(self) -> str:
        """Determine region based on country code"""
        country_to_region = {
            # North America
            'US': 'North America', 'CA': 'North America', 'MX': 'North America',
            # Europe
            'GB': 'Europe', 'FR': 'Europe', 'DE': 'Europe', 'IT': 'Europe',
            'ES': 'Europe', 'PT': 'Europe', 'BE': 'Europe', 'NL': 'Europe',
            'CH': 'Europe', 'AT': 'Europe', 'SE': 'Europe', 'NO': 'Europe',
            'DK': 'Europe', 'FI': 'Europe', 'IE': 'Europe',
            # Asia
            'JP': 'Asia', 'KR': 'Asia', 'CN': 'Asia', 'TW': 'Asia',
                'HK': 'Asia', 'SG': 'Asia', 'MY': 'Asia', 'ID': 'Asia',
                'TH': 'Asia', 'VN': 'Asia', 'PH': 'Asia',
                # South America
                'BR': 'South America', 'AR': 'South America', 'CL': 'South America'
            }
        return country_to_region.get(self.country, "Unknown")
    
    @property
    def safe_region(self) -> str:
        return self.safe_value(self.region)

class M3UConverter:
    """
    Main converter class that handles the M3U processing and YAML generation.
    
    This class manages:
    - Directory structure creation
    - M3U download and parsing
    - Channel organization
    - YAML file generation
    """
    
    def __init__(self):
        """Initialize converter with predefined categories and empty channel list"""
        self.categories = [
            "Animation", "Auto", "Business", "Classic", "Comedy",
            "Cooking", "Culture", "Documentary", "Education",
            "Entertainment", "Family", "General", "Kids",
            "Legislative", "Lifestyle", "Movies", "Music",
            "News", "Outdoor", "Relax", "Religious", "Science",
            "Series", "Shop", "Sports", "Travel", "Weather",
            "XXX", "Undefined"
        ]
        self.base_dir = Path("channels")
        self.channels: List[Channel] = []
        self.config = Config()

    def init_directories(self):
        """Create required directory structure"""
        dirs = [
            self.base_dir,
            self.base_dir / "categories",
            self.base_dir / "language",
            self.base_dir / "region",
            self.base_dir / "country"
        ]
        for dir_path in dirs:
            dir_path.mkdir(parents=True, exist_ok=True)

    async def fetch_m3u(self, url: str) -> str:
        """
        Download M3U file from URL
        
        Args:
            url: The URL of the M3U playlist
            
        Returns:
            str: The content of the M3U file
        """
        async with aiohttp.ClientSession() as session:
            async with session.get(url) as response:
                return await response.text()

    def parse_m3u(self, content: str):
        """
        Parse M3U content and extract channel information
        
        Args:
            content: The M3U file content to parse
        """
        lines = content.splitlines()
        current_info = None

        for line in lines:
            if line.startswith('#EXTINF:'):
                # Extract metadata using regex
                info = {
                    'tvg-id': re.search(r'tvg-id="([^"]*)"', line),
                    'tvg-logo': re.search(r'tvg-logo="([^"]*)"', line),
                    'group-title': re.search(r'group-title="([^"]*)"', line),
                    'tvg-country': re.search(r'tvg-country="([^"]*)"', line),
                    'tvg-language': re.search(r'tvg-language="([^"]*)"', line)
                }
                current_info = {k: v.group(1) if v else "Unknown" for k, v in info.items()}
            
            elif line.startswith('http') and current_info:
                channel = Channel(
                    number=len(self.channels) + 1,
                    abbr=current_info['tvg-id'][:5] or f"CH{len(self.channels) + 1}",
                    name=current_info['group-title'],
                    title=current_info['group-title'],
                    description=f"Channel: {current_info['group-title']}\nCategory: {current_info['group-title']}\nCountry: {current_info['tvg-country']}\nLanguage: {current_info['tvg-language']}",
                    logo=current_info['tvg-logo'] or "placeholders/example-program.gif",
                    url=line,
                    category=current_info['group-title'],
                    country=current_info['tvg-country'],
                    language=current_info['tvg-language']
                )
                self.channels.append(channel)
                current_info = None

    def generate_yaml(self, channels: List[Channel], filename: str, category: Optional[str] = None):
        """
        Generate a TVS YAML file for a list of channels
        
        Args:
            channels: List of channels to include
            filename: Output filename
            category: Optional category name for the title
        """
        config = self.config.__dict__.copy()
        if category:
            config['title'] = f"{config['title']} - {category}"
        
        data = {
            **config,
            'channels': [{
                'number': ch.number,
                'abbr': ch.abbr,
                'name': ch.name,
                'title': ch.title,
                'description': ch.description,
                'loop': [
                    {'image': ch.logo, 'duration': 1},
                    {'video': {'provider': 'hls', 'src': ch.url, 'hlsBugFix': True}},
                    {'image': ch.logo, 'duration': 1}
                ]
            } for ch in channels]
        }

        with open(filename, 'w') as f:
            yaml.dump(data, f, sort_keys=False, allow_unicode=True)

    def organize_channels(self):
        """
        Organize channels by category, language, region, and country.
        Creates separate YAML files for each organization type.
        """
        # Process categories
        for category in self.categories:
            category_channels = [ch for ch in self.channels if ch.category == category]
            if category_channels:
                safe_category = category_channels[0].safe_category
                self.generate_yaml(
                    category_channels,
                    self.base_dir / "categories" / f"{safe_category}.tvs.yml",
                    category
                )

        # Organize by attributes
        organizations = {
            'language': lambda ch: ch.safe_language,
            'region': lambda ch: ch.safe_region,
            'country': lambda ch: ch.safe_country
        }

        # Create organization files
        for org_type, get_value in organizations.items():
            # Group channels by the organization type
            grouped = {}
            for channel in self.channels:
                value = get_value(channel)
                if value != "unknown":
                    if value not in grouped:
                        grouped[value] = []
                    grouped[value].append(channel)
            
            # Generate files for each group
            for value, channels in grouped.items():
                filename = self.base_dir / org_type / f"{value}.tvs.yml"
                self.generate_yaml(channels, filename, value)

    async def convert(self, url: str):
        """Main conversion process"""
        self.init_directories()
        
        content = await self.fetch_m3u(url)
        self.parse_m3u(content)
        
        # Generate main index file
        self.generate_yaml(self.channels, self.base_dir / "index.tvs.yml")
        
        # Generate organization files
        self.organize_channels()

def main(stdscr):
    # Set up curses
    curses.start_color()
    curses.init_pair(1, curses.COLOR_BLUE, curses.COLOR_BLACK)
    curses.init_pair(2, curses.COLOR_GREEN, curses.COLOR_BLACK)
    
    # Get URL
    stdscr.addstr(0, 0, "Enter M3U URL: ", curses.color_pair(1))
    editwin = curses.newwin(1, 60, 1, 0)
    box = Textbox(editwin)
    stdscr.refresh()
    box.edit()
    url = box.gather().strip()

    # Process
    converter = M3UConverter()
    asyncio.run(converter.convert(url))

    # Show completion
    stdscr.clear()
    stdscr.addstr(0, 0, "Conversion complete!", curses.color_pair(2))
    stdscr.addstr(2, 0, f"Processed {len(converter.channels)} channels")
    stdscr.addstr(3, 0, "Files created in ./channels/")
    stdscr.refresh()
    stdscr.getch()

if __name__ == "__main__":
    if len(sys.argv) > 1:
        asyncio.run(M3UConverter().convert(sys.argv[1]))
    else:
        curses.wrapper(main)