#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Simple Agenda Informe Scraper → ICS Calendar Generator
Scrape agenda-informe.com and generate calendar.ics for Google Calendar import
ZERO EXTERNAL DEPENDENCIES - Uses ONLY native Python libraries
"""
import sys
import io

# Force UTF-8 output on Windows
if sys.stdout.encoding != 'utf-8':
    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')

from urllib.request import urlopen, Request
from urllib.error import URLError
from datetime import datetime, timedelta
import json
import time
import re

# Configuration
SCRAPE_URL = "https://agenda-informe.com/agenda"
OUTPUT_FILE = "calendar.ics"
CACHE_FILE = "events_cache.json"

def scrape_events():
    """Scrape all events from agenda-informe.com using only native Python"""
    print("[*] Scraping agenda-informe.com...")
    events = []
    
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    }
    
    try:
        page = 1
        while True:
            url = f"{SCRAPE_URL}/" if page == 1 else f"{SCRAPE_URL}/?page={page}"
            print(f"    Page {page}...", end=" ", flush=True)
            
            try:
                req = Request(url, headers=headers)
                response = urlopen(req, timeout=10)
                html_content = response.read().decode('utf-8', errors='ignore')
            except URLError as e:
                print(f"Error")
                break
            
            # Extract using regex (no HTML parser needed)
            event_blocks = re.findall(
                r'(?:<div|<article|<li|<section)[^>]*>.*?(?:</div>|</article>|</li>|</section>)',
                html_content,
                re.DOTALL
            )[:100]
            
            if not event_blocks:
                print("No elements found")
                break
            
            events_on_page = 0
            for block in event_blocks:
                try:
                    text_content = re.sub(r'<[^>]+>', ' ', block)
                    text_content = re.sub(r'\s+', ' ', text_content).strip()
                    
                    if len(text_content) < 10:
                        continue
                    
                    date_pattern = r'\d{1,2}[/-]\d{1,2}(?:[/-]\d{2,4})?\s*(?:\d{1,2}:\d{2})?'
                    date_match = re.search(date_pattern, text_content)
                    if not date_match:
                        continue
                    
                    date_text = date_match.group()
                    title = text_content[:200]
                    
                    for prefix in ['le ', 'la ', 'l\'', 'le  ', 'venez ', 'à ', 'du ']:
                        if title.lower().startswith(prefix):
                            title = title[len(prefix):]
                    
                    title = title.split('\n')[0].strip()[:100]
                    if not title or len(title) < 3:
                        title = "Événement - " + date_text
                    
                    location_text = ""
                    for loc_word in ['lieu:', 'à', 'location:', '@', 'adresse:']:
                        if loc_word.lower() in text_content.lower():
                            parts = text_content.split(loc_word, 1)
                            if len(parts) > 1:
                                location_text = parts[1].split('\n')[0].strip()[:100]
                                break
                    
                    if title and date_text:
                        events.append({
                            'title': title,
                            'date': date_text,
                            'location': location_text or "Lieu TBD",
                            'description': text_content[:200]
                        })
                        events_on_page += 1
                        
                except Exception:
                    continue
            
            print(f"✓ Found {events_on_page} events")
            
            if events_on_page == 0:
                break
            
            time.sleep(1)
            page += 1
            
            if page > 10:
                print("    Reached page limit")
                break
        
        print(f"[+] Total events scraped: {len(events)}")
        return events
    
    except Exception as e:
        print(f"[!] Scraping error: {e}")
        return []

def parse_date_time(date_str):
    """Parse flexible date format to datetime"""
    formats = [
        "%d/%m/%Y %H:%M",
        "%d/%m/%Y %H:%M:%S",
        "%d/%m/%Y",
        "%d-%m-%Y %H:%M",
        "%d-%m-%Y",
        "%Y-%m-%d %H:%M",
        "%Y-%m-%d"
    ]
    
    date_clean = date_str.strip()
    
    for fmt in formats:
        try:
            return datetime.strptime(date_clean, fmt)
        except ValueError:
            continue
    
    try:
        match = re.search(r'(\d{1,2})[/-](\d{1,2})(?:[/-](\d{2,4}))?\s*(?:(\d{1,2}):(\d{2}))?', date_clean)
        if match:
            day, month, year, hour, minute = match.groups()
            year = year or str(datetime.now().year)
            hour = int(hour or 19)
            minute = int(minute or 0)
            
            if len(str(year)) == 2:
                year = 2000 + int(year) if int(year) < 50 else 1900 + int(year)
            else:
                year = int(year)
            
            return datetime(int(year), int(month), int(day), hour, minute)
    except:
        pass
    
    return datetime.now() + timedelta(days=1, hours=19)

def generate_ics(events, filename=OUTPUT_FILE):
    """Generate RFC 5545 iCalendar file"""
    print(f"[*] Generating {filename}...")
    
    ics_content = "BEGIN:VCALENDAR\nVERSION:2.0\nPRODID:-//Agenda Informe//Scraper//EN\n"
    
    event_count = 0
    for i, event in enumerate(events):
        try:
            dt = parse_date_time(event['date'])
            if not dt:
                continue
            
            uid = f"event-{i}-{int(time.time())}@agenda-informe.com"
            dt_end = dt + timedelta(hours=2)
            
            title_esc = event['title'].replace('\n', ' ')[:100]
            location_esc = event['location'].replace('\n', ' ')[:100]
            desc_esc = event['description'].replace('\n', ' ')[:200]
            
            ics_content += "BEGIN:VEVENT\n"
            ics_content += f"UID:{uid}\n"
            ics_content += f"DTSTAMP:{datetime.now().strftime('%Y%m%dT%H%M%SZ')}\n"
            ics_content += f"DTSTART:{dt.strftime('%Y%m%dT%H%M%S')}\n"
            ics_content += f"DTEND:{dt_end.strftime('%Y%m%dT%H%M%S')}\n"
            ics_content += f"SUMMARY:{title_esc}\n"
            ics_content += f"LOCATION:{location_esc}\n"
            ics_content += f"DESCRIPTION:{desc_esc}\n"
            ics_content += "END:VEVENT\n"
            event_count += 1
        except Exception:
            continue
    
    ics_content += "END:VCALENDAR"
    
    with open(filename, 'w', encoding='utf-8') as f:
        f.write(ics_content)
    
    print(f"[+] Generated {event_count} events")

def cache_events(events):
    """Cache events to JSON"""
    with open(CACHE_FILE, 'w', encoding='utf-8') as f:
        json.dump(events, f, indent=2, ensure_ascii=False)
    print(f"[+] Cached {len(events)} events")

if __name__ == '__main__':
    events = scrape_events()
    
    if not events:
        print("[!] No events found!")
        sys.exit(1)
    
    generate_ics(events)
    cache_events(events)
    
    print(f"\n✅ Done! Generated {OUTPUT_FILE} and {CACHE_FILE}")