#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import re
import requests
import json
import time
from urllib.parse import parse_qs, urlparse
from config import USER_AGENT

def check_url_patterns(url):
    """
    Memeriksa apakah URL adalah URL Terabox yang valid.
    
    Args:
        url (str): URL yang akan diperiksa
        
    Returns:
        bool: True jika URL adalah URL Terabox yang valid, False jika tidak
    """
    patterns = [
        r"ww\.mirrobox\.com",
        r"www\.nephobox\.com",
        r"freeterabox\.com",
        r"www\.freeterabox\.com",
        r"1024tera\.com",
        r"4funbox\.co",
        r"www\.4funbox\.com",
        r"mirrobox\.com",
        r"nephobox\.com",
        r"terabox\.app",
        r"terabox\.com",
        r"www\.terabox\.ap",
        r"www\.terabox\.com",
        r"www\.1024tera\.co",
        r"www\.momerybox\.com",
        r"teraboxapp\.com",
        r"momerybox\.com",
        r"tibibox\.com",
        r"www\.tibibox\.com",
        r"www\.teraboxapp\.com",
    ]
    
    for pattern in patterns:
        if re.search(pattern, url):
            return True
    return False

def get_formatted_size(size_in_bytes):
    """
    Mengubah ukuran dalam bytes menjadi format yang mudah dibaca.
    
    Args:
        size_in_bytes (int): Ukuran dalam bytes
        
    Returns:
        str: Ukuran dalam format yang mudah dibaca (KB, MB, GB)
    """
    if size_in_bytes < 1024:
        return f"{size_in_bytes} B"
    elif size_in_bytes < 1024 * 1024:
        return f"{size_in_bytes / 1024:.2f} KB"
    elif size_in_bytes < 1024 * 1024 * 1024:
        return f"{size_in_bytes / (1024 * 1024):.2f} MB"
    else:
        return f"{size_in_bytes / (1024 * 1024 * 1024):.2f} GB"

def extract_terabox_url(text):
    """
    Mengekstrak URL Terabox dari teks.
    
    Args:
        text (str): Teks yang berisi URL Terabox
        
    Returns:
        str or None: URL Terabox jika ditemukan, None jika tidak
    """
    pattern = r"(https?://\S+)"
    urls = re.findall(pattern, text)
    
    for url in urls:
        if check_url_patterns(url):
            return url
    
    return None

def get_terabox_download_link(url):
    """
    Mendapatkan link download langsung dari URL Terabox.
    
    Args:
        url (str): URL Terabox
        
    Returns:
        dict: Informasi file termasuk link download, nama file, ukuran, dll.
              Atau None jika gagal
    """
    try:
        print(f"Processing URL: {url}")
        
        # Metode 1: Menggunakan API ytshorts.savetube.me
        headers = {
            "User-Agent": USER_AGENT,
            "Accept": "application/json, text/plain, */*",
            "Content-Type": "application/json",
            "Origin": "https://ytshorts.savetube.me",
            "Referer": "https://ytshorts.savetube.me/",
        }
        
        api_url = "https://ytshorts.savetube.me/api/v1/terabox-downloader"
        response = requests.post(
            api_url,
            headers=headers,
            json={"url": url},
            timeout=30
        )
        
        print(f"API Response Status: {response.status_code}")
        
        if response.status_code == 200:
            try:
                data = response.json()
                print(f"API Response Data: {json.dumps(data, indent=2)}")
                
                responses = data.get("response", [])
                if responses:
                    resolutions = responses[0].get("resolutions", {})
                    if resolutions:
                        download_link = resolutions.get("Fast Download", "")
                        video_link = resolutions.get("HD Video", "")
                        
                        if download_link or video_link:
                            # Dapatkan informasi file dari header
                            file_name = None
                            file_size = None
                            direct_link = None
                            
                            if video_link:
                                try:
                                    response = requests.head(video_link, timeout=10)
                                    content_length = response.headers.get("Content-Length", 0)
                                    
                                    content_disposition = response.headers.get("content-disposition")
                                    if content_disposition:
                                        file_name_match = re.findall('filename="(.+)"', content_disposition)
                                        if file_name_match:
                                            file_name = file_name_match[0]
                                    
                                    if content_length:
                                        file_size = int(content_length)
                                except Exception as e:
                                    print(f"Error getting video link info: {str(e)}")
                            
                            if download_link:
                                try:
                                    response = requests.head(download_link, timeout=10, allow_redirects=True)
                                    direct_link = response.url
                                except Exception as e:
                                    print(f"Error getting direct link: {str(e)}")
                                    direct_link = download_link
                            
                            # Jika tidak ada nama file, ekstrak dari URL
                            if not file_name:
                                path = urlparse(url).path
                                if path:
                                    file_name = path.split('/')[-1]
                                    if not file_name:
                                        file_name = "terabox_file"
                            
                            # Buat data hasil
                            return {
                                "file_name": file_name,
                                "link": video_link or direct_link,
                                "direct_link": direct_link or download_link,
                                "thumb": None,
                                "size": get_formatted_size(file_size) if file_size else "Unknown",
                                "size_bytes": file_size,
                            }
            except Exception as e:
                print(f"Error parsing API response: {str(e)}")
        
        # Metode 2: Menggunakan API gofile.io sebagai alternatif
        # Ini adalah simulasi untuk tujuan demonstrasi
        # Dalam implementasi nyata, kita perlu mengupload file ke gofile.io terlebih dahulu
        
        # Fallback: Menggunakan metode scraping sederhana
        try:
            # Ubah domain ke 1024terabox.com untuk konsistensi
            netloc = urlparse(url).netloc
            url = url.replace(netloc, "1024terabox.com")
            
            headers = {
                "User-Agent": USER_AGENT,
                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
                "Accept-Language": "en-US,en;q=0.5",
            }
            
            response = requests.get(url, headers=headers, timeout=10)
            print(f"Scraping Response Status: {response.status_code}")
            
            if response.status_code == 200:
                # Coba ekstrak nama file dari halaman
                file_name_match = re.search(r'<title>(.*?) - Terabox</title>', response.text)
                file_name = file_name_match.group(1) if file_name_match else "terabox_file"
                
                # Coba ekstrak thumbnail dari halaman
                thumbnail_match = re.search(r'og:image" content="([^"]+)"', response.text)
                thumbnail = thumbnail_match.group(1) if thumbnail_match else None
                
                # Karena kita tidak bisa mendapatkan link download langsung dengan scraping sederhana,
                # kita hanya mengembalikan informasi file yang berhasil diekstrak
                return {
                    "file_name": file_name,
                    "link": url,  # Gunakan URL asli sebagai link
                    "direct_link": url,  # Tidak ada link download langsung
                    "thumb": thumbnail,
                    "size": "Unknown",
                    "size_bytes": None,
                    "requires_premium": True,  # Tandai bahwa file ini memerlukan akses premium
                }
        except Exception as e:
            print(f"Error scraping page: {str(e)}")
        
        # Jika semua metode gagal, kembalikan informasi dasar
        return {
            "file_name": "terabox_file",
            "link": url,
            "direct_link": url,
            "thumb": None,
            "size": "Unknown",
            "size_bytes": None,
            "requires_premium": True,
            "message": "Tidak dapat mengekstrak link download langsung. File ini mungkin memerlukan akses premium atau URL tidak valid."
        }
    
    except Exception as e:
        print(f"Error getting Terabox download link: {str(e)}")
        return None
