from pathlib import Path
import requests
from bs4 import BeautifulSoup
import re

def load_cookies():
    """خواندن کوکی از فایل logedin.txt"""
    cookie_file = Path('logedin.txt')
    if not cookie_file.exists():
        raise FileNotFoundError("Error: logedin.txt not found!")
    with cookie_file.open('r', encoding='utf-8') as f:
        return {'wordpress_logged_in_7a04687845b0293923d85c8b5afee67b': f.readline().strip()}

def setup_headers():
    """تنظیم هدرهای درخواست HTTP"""
    return {
        'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
        'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36',
    }

def clear_output_file():
    """حذف فایل linkss2.txt اگر وجود داشته باشد"""
    output_file = Path('linkss2.txt')
    if output_file.exists():
        output_file.unlink()

def filter_links_by_quality(links, season, episode, quality, is_dubbed, is_series=True):
    """فیلتر کردن لینک‌ها برای انتخاب آخرین لینک غیر-x265 با کیفیت مشخص"""
    quality_pattern = {
        '360p': r'360p',
        '480p': r'480p',
        '540p': r'540p',
        '720p': r'720p',
        '1080p': r'1080p',
        'DVDRip': r'dvdrip',
    }[quality]
    
    if is_series:
        filtered = [
            link for link in links
            if f'/S{season:02d}/' in link['href']
            and f'E{episode:02d}' in link['href']
            and re.search(quality_pattern, link['href'], re.IGNORECASE)
            and 'x265' not in link['href'].lower()
            and ('Dubbed' in link['href'] if is_dubbed else 'Dubbed' not in link['href'])
        ]
    else:
        filtered = [
            link for link in links
            if re.search(quality_pattern, link['href'], re.IGNORECASE)
            and 'x265' not in link['href'].lower()
            and ('Dubbed' in link['href'] if is_dubbed else 'Dubbed' not in link['href'])
        ]
    
    return filtered[-1] if filtered else None

def scrape_mkv_links(id, name, imdb, cookies, headers):
    """اسکرپ کردن لینک‌های دانلود سریال با انتخاب کیفیت‌های کم‌حجم غیر-x265"""
    url = f'https://zhomis.info/?p={id}'
    try:
        response = requests.get(url, cookies=cookies, headers=headers, timeout=20)
        response.raise_for_status()
        
        soup = BeautifulSoup(response.text, 'html.parser')
        
        # بررسی وجود پخش آنلاین
        online_btn = soup.find('a', class_='btn_left_single online_btn')
        if online_btn:
            print(f"Skipping ID {id} because it has online streaming")
            return
        
        dlbox = soup.find('div', class_='single_dlbox')
        movie_box = soup.find('div', class_='inner_dl_box_n_single')
        
        output_lines = []
        links_found = False

        # بخش فیلم‌ها (کامنت‌شده)
        """
        if movie_box:
            # بررسی زیرنویس برای فیلم
            subtitle_tag = movie_box.find('span', class_='label_dl_row subtitle_row')
            if not subtitle_tag or 'بدون زیرنویس' in subtitle_tag.text.lower():
                print(f"Skipping movie ID {id} because it has no subtitle")
                return
            
            movie_links = [
                {'href': link_tag['href'], 'text': link_tag.get_text(strip=True)}
                for link_tag in movie_box.find_all('a', class_='dllink subtitle_link')
                if link_tag['href'].startswith('https') and ('.mkv' in link_tag['href'] or '.mp4' in link_tag['href'])
            ]
            
            qualities = ['1080p', '720p', '540p', '480p', '360p', 'DVDRip']
            for quality in qualities:
                for is_dubbed in [False, True]:
                    link = filter_links_by_quality(movie_links, 1, 1, quality, is_dubbed, is_series=False)
                    if link:
                        href = link['href']
                        cleaned_link = href.split('.mkv')[0] + '.mkv' if '.mkv' in href else href.split('.mp4')[0] + '.mp4'
                        vtt_link = href.split('.mkv')[0] + '.vtt' if '.mkv' in href else href.split('.mp4')[0] + '.vtt'
                        output_lines.append(f"{id};{name};{imdb};{cleaned_link}")
                        output_lines.append(f"{id};{name};{imdb};{vtt_link}")
                        links_found = True
                        print(f"Found {'dubbed' if is_dubbed else 'subtitle'} movie link for ID {id} ({quality}): {cleaned_link}")
        """

        # بررسی سریال‌ها
        if dlbox:
            # جمع‌آوری تمام لینک‌ها
            all_links = [
                {'href': link_tag['href'], 'text': link_tag.get_text(strip=True)}
                for link_tag in dlbox.find_all('a', href=True)
                if link_tag['href'].startswith('https') and ('.mkv' in link_tag['href'] or '.mp4' in link_tag['href'])
            ]
            
            # استخراج فصل‌ها
            seasons = sorted(set(
                int(re.search(r'/S(\d+)/', link['href']).group(1))
                for link in all_links
                if re.search(r'/S(\d+)/', link['href'])
            ))
            
            # بررسی زیرنویس و لینک‌های غیر-x265 برای هر فصل
            qualities = ['1080p', '720p', '540p', '480p', '360p', 'DVDRip']
            for season in seasons:
                season_has_subtitle = False
                season_has_non_x265 = False
                
                # بررسی زیرنویس
                quality_items = dlbox.find_all('div', class_='item_quality_n_row')
                for item in quality_items:
                    season_name = item.find_previous('div', class_='season_name')
                    if season_name and f'فصل {season}' in season_name.text:
                        subtitle_tag = item.find('div', class_='label_row_q_n')
                        if subtitle_tag and 'بدون زیرنویس' not in subtitle_tag.text.lower():
                            season_has_subtitle = True
                            break
                
                # بررسی وجود لینک غیر-x265
                season_links = [link for link in all_links if f'/S{season:02d}/' in link['href']]
                for quality in qualities:
                    for is_dubbed in [False, True]:
                        link = filter_links_by_quality(season_links, season, 1, quality, is_dubbed, is_series=True)
                        if link:
                            season_has_non_x265 = True
                            break
                    if season_has_non_x265:
                        break
                
                # رد شدن سریال اگه فصل زیرنویس یا لینک غیر-x265 نداشته باشه
                if not season_has_subtitle:
                    print(f"Skipping series ID {id} because season {season} has no subtitle")
                    return
                if not season_has_non_x265:
                    print(f"Skipping series ID {id} because season {season} has only x265 links")
                    return
            
            # پردازش لینک‌ها برای فصل‌های معتبر
            episodes_per_season = {}
            for season in seasons:
                episodes = sorted(set(
                    int(re.search(r'E(\d+)', link['href']).group(1))
                    for link in all_links
                    if f'/S{season:02d}/' in link['href'] and re.search(r'E(\d+)', link['href'])
                ))
                episodes_per_season[season] = max(episodes) if episodes else 1
            
            # تنظیم اپیزودهای دوبله
            dubbed_episodes = {}
            for season in seasons:
                dubbed_episodes[season] = 6 if season == 2 else episodes_per_season[season]
            
            for season in seasons:
                max_episodes = episodes_per_season[season]
                # نسخه‌های زیرنویس‌دار
                for quality in qualities:
                    for episode in range(1, max_episodes + 1):
                        link = filter_links_by_quality(all_links, season, episode, quality, is_dubbed=False, is_series=True)
                        if link:
                            href = link['href']
                            cleaned_link = href.split('.mkv')[0] + '.mkv' if '.mkv' in href else href.split('.mp4')[0] + '.mp4'
                            vtt_link = href.split('.mkv')[0] + '.vtt' if '.mkv' in href else href.split('.mp4')[0] + '.vtt'
                            output_lines.append(f"{id};{name};{episode};{season};{imdb};{vtt_link};{cleaned_link}")
                            links_found = True
                            print(f"Found subtitle link for S{season:02d}E{episode:02d} ({quality}): {cleaned_link}")
                
                # نسخه‌های دوبله
                max_dubbed_episodes = dubbed_episodes[season]
                for quality in qualities:
                    for episode in range(1, max_dubbed_episodes + 1):
                        link = filter_links_by_quality(all_links, season, episode, quality, is_dubbed=True, is_series=True)
                        if link:
                            href = link['href']
                            cleaned_link = href.split('.mkv')[0] + '.mkv' if '.mkv' in href else href.split('.mp4')[0] + '.mp4'
                            vtt_link = href.split('.mkv')[0] + '.vtt' if '.mkv' in href else href.split('.mp4')[0] + '.vtt'
                            output_lines.append(f"{id};{name};{episode};{season};{imdb};{vtt_link};{cleaned_link}")
                            links_found = True
                            print(f"Found dubbed link for S{season:02d}E{episode:02d} ({quality}): {cleaned_link}")
        
        # نوشتن لینک‌ها در فایل
        if output_lines:
            with Path('linkss2.txt').open('a', encoding='utf-8') as add:
                for line in output_lines:
                    add.write(f"{line}\n")
        
        print(f"{'No links found' if not links_found else 'All selected links written'} to linkss2.txt for ID {id}")
    
    except requests.RequestException as e:
        print(f"Error loading /?p={id}: {e}")

def main():
    """تابع اصلی برای پردازش IDها و اسکرپ کردن لینک‌ها"""
    try:
        cookies = load_cookies()
        headers = setup_headers()
        clear_output_file()
        
        id_file = Path('zarfilm_ids_container.txt')
        if not id_file.exists():
            raise FileNotFoundError("Error: zarfilm_ids_container.txt not found!")
        
        with id_file.open('r', encoding='utf-8') as f:
            ids = [line.strip() for line in f if line.strip()]
        
        for id in ids:
            print(f"Processing ID: {id}")
            url = f'https://zhomis.info/?p={id}'
            try:
                response = requests.get(url, cookies=cookies, headers=headers, timeout=20)
                response.raise_for_status()
                
                soup = BeautifulSoup(response.text, 'html.parser')
                name_tag = soup.find('h1', class_='entry-title')
                if not name_tag:
                    name_tag = soup.find('h1')
                if not name_tag:
                    name_tag = soup.find('title')
                name = name_tag.text.strip() if name_tag else f"دانلود {id}"
                name = re.sub(r'^(دانلود|فیلم|سریال)\s+', '', name, flags=re.IGNORECASE).strip()
                name = f"دانلود {name}" if not name.startswith('دانلود') else name
                
                imdb_link = soup.find('a', href=re.compile(r'imdb.com/title/tt\d+'))
                imdb = re.search(r'tt\d+', imdb_link['href']).group() if imdb_link else 'tt0000000'
                
                scrape_mkv_links(id, name, imdb, cookies, headers)
            
            except requests.RequestException as e:
                print(f"Error loading /?p={id} for name and IMDb: {e}")
    
    except Exception as e:
        print(f"Unexpected error: {e}")

if __name__ == "__main__":
    main()