import asyncio
import aiohttp
import csv
import os
import re
from bs4 import BeautifulSoup
from urllib.parse import urljoin, urlparse
import logging
from typing import List, Dict, Optional, Set
import time

# Настройка логирования
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

class InfostartForumParser:
    def __init__(self, csv_file: str = 'forum_dataset.csv', delay: float = 1.0):
        self.csv_file = csv_file
        self.delay = delay  # Задержка между запросами
        self.base_url = 'https://forum.infostart.ru/group2'
        self.processed_urls: Set[str] = set()
        
        # Создаем CSV файл с заголовками если его нет
        self._init_csv()
        
        # Загружаем уже обработанные URL из CSV
        self._load_processed_urls()
    
    def _init_csv(self):
        """Инициализация CSV файла с заголовками"""
        if not os.path.exists(self.csv_file):
            with open(self.csv_file, 'w', newline='', encoding='utf-8') as file:
                writer = csv.writer(file, quoting=csv.QUOTE_ALL)  # Полное квотирование для сохранения пробелов
                writer.writerow(['source', 'in_source_id', 'prompt', 'gold_standard_solution'])
    
    def _load_processed_urls(self):
        """Загрузка уже обработанных URL из CSV"""
        if os.path.exists(self.csv_file):
            with open(self.csv_file, 'r', encoding='utf-8') as file:
                reader = csv.DictReader(file)
                for row in reader:
                    if row['in_source_id']:
                        self.processed_urls.add(row['in_source_id'])
        logger.info(f"Загружено {len(self.processed_urls)} уже обработанных URL")
    
    async def fetch_page(self, session: aiohttp.ClientSession, url: str) -> Optional[str]:
        """Получение содержимого страницы"""
        try:
            await asyncio.sleep(self.delay)  # Задержка между запросами
            async with session.get(url, timeout=30) as response:
                if response.status == 200:
                    return await response.text()
                else:
                    logger.warning(f"Ошибка {response.status} при загрузке {url}")
                    return None
        except Exception as e:
            logger.error(f"Ошибка при загрузке {url}: {e}")
            return None
    
    async def parse_topic_list_page(self, session: aiohttp.ClientSession, page_num: int) -> List[str]:
        """Парсинг страницы списка тем"""
        url = f"{self.base_url}/?a=26694&PAGEN_1={page_num}"
        logger.info(f"Парсинг страницы списка тем: {page_num}")
        
        html = await self.fetch_page(session, url)
        if not html:
            return []
        
        soup = BeautifulSoup(html, 'html.parser')
        topic_urls = []
        
        # Находим div.forum-topic-list
        forum_topic_list = soup.find('div', class_='forum-topic-list')
        if not forum_topic_list:
            logger.warning(f"Не найден div.forum-topic-list на странице {page_num}")
            return []
        
        # Ищем все div.nff-font110
        topic_divs = forum_topic_list.find_all('div', class_='nff-font110')
        logger.info(f"Найдено {len(topic_divs)} тем на странице {page_num}")
        
        for topic_div in topic_divs:
            # Проверяем есть ли тег <a> с текстом "Dev"
            dev_link = topic_div.find('a', string='Dev')
            if dev_link:
                # Ищем ссылку на тему (обычно первая ссылка в div)
                topic_link = topic_div.find('a', href=re.compile(r'/forum\d+/topic\d+/'))
                if topic_link:
                    topic_url = urljoin(self.base_url, topic_link['href'])
                    topic_urls.append(topic_url)
        
        logger.info(f"Найдено {len(topic_urls)} тем с меткой Dev на странице {page_num}")
        return topic_urls
    
    def extract_topic_id(self, url: str) -> Optional[str]:
        """Извлечение ID темы из URL"""
        match = re.search(r'/forum\d+/(topic\d+)/', url)
        return match.group(1) if match else None
    
    def extract_meta_identifier(self, soup: BeautifulSoup) -> Optional[str]:
        """Извлечение identifier из meta тега"""
        meta_tag = soup.find('meta', attrs={'itemprop': 'identifier'})
        return meta_tag.get('content') if meta_tag else None
    
    def extract_first_message(self, soup: BeautifulSoup) -> Optional[str]:
        """Извлечение первого сообщения (вопроса)"""
        # Ищем первый div с классом post-mesages
        post_messages = soup.find('div', class_='post-mesages')
        if not post_messages:
            return None
        
        # Ищем первое сообщение
        first_message_div = post_messages.find('div', class_='m-tree-p')
        if not first_message_div:
            return None
        
        # Извлекаем текст сообщения
        message_text_div = first_message_div.find('div', class_='forum-message-text')
        if not message_text_div:
            return None
        
        return self.clean_message_text(message_text_div)
    
    def extract_solutions(self, soup: BeautifulSoup) -> List[str]:
        """Извлечение решений из секции 'Найденные решения'"""
        solutions = []
        
        # Ищем секцию "Найденные решения"
        found_solutions_header = soup.find(text=re.compile(r'Найденные решения'))
        if not found_solutions_header:
            return solutions
        
        # Находим следующий элемент после заголовка
        solutions_section = found_solutions_header.find_parent().find_next_sibling()
        if not solutions_section:
            return solutions
        
        # Ищем все сообщения в секции решений
        solution_divs = solutions_section.find_all('div', class_='m-tree-p')
        
        for solution_div in solution_divs:
            message_text_div = solution_div.find('div', class_='forum-message-text')
            if message_text_div:
                solution_text = self.clean_message_text(message_text_div)
                if solution_text:
                    # Очищаем от цифр в скобках в начале
                    solution_text = self.clean_solution_text(solution_text)
                    if solution_text:  # Проверяем, что текст не пустой после очистки
                        solutions.append(solution_text)
        
        return solutions
    
    def clean_message_text(self, message_div) -> str:
        """Очистка и форматирование текста сообщения"""
        # Создаем копию для работы, чтобы не изменять оригинал
        message_copy = message_div.__copy__()
        
        # Обрабатываем блоки кода
        code_blocks = message_copy.find_all('div', class_='code')
        for code_block in code_blocks:
            pre_tag = code_block.find('pre')
            if pre_tag:
                # Извлекаем код с сохранением структуры HTML
                code_text = self.extract_code_from_pre(pre_tag)
                
                # Создаем новый элемент для замены
                from bs4 import NavigableString
                replacement_text = f"\n```1c\n{code_text}\n```\n"
                code_block.replace_with(NavigableString(replacement_text))
        
        # Заменяем <br> на переносы строк
        for br in message_copy.find_all('br'):
            br.replace_with('\n')
        
        # Удаляем цитаты и другие служебные элементы
        for quote in message_copy.find_all('div', class_='quote-wrap'):
            quote.decompose()
        
        # Удаляем служебные элементы
        for element in message_copy.find_all(['script', 'style']):
            element.decompose()
        
        # Получаем чистый текст
        text = message_copy.get_text()
        
        # Очищаем от множественных переносов строк, но сохраняем одиночные
        text = re.sub(r'\n\s*\n\s*\n+', '\n\n', text)  # Множественные переносы -> двойной перенос
        
        # НЕ удаляем пробелы в начале строк - это может быть отступ кода!
        # Только очищаем trailing пробелы и нормализуем множественные пробелы
        lines = text.split('\n')
        cleaned_lines = []
        for line in lines:
            # Удаляем trailing пробелы, но сохраняем leading пробелы
            line = line.rstrip()
            # Нормализуем множественные пробелы только внутри строки (не в начале)
            if line.lstrip():  # Если строка не пустая
                leading_spaces = len(line) - len(line.lstrip())
                content = line.lstrip()
                # Нормализуем пробелы только в содержимом, не в отступах
                content = re.sub(r'[ \t]+', ' ', content)
                line = ' ' * leading_spaces + content
            cleaned_lines.append(line)
        
        text = '\n'.join(cleaned_lines).strip()
        
        return text
    
    def extract_code_from_pre(self, pre_tag) -> str:
        """Извлечение кода из тега <pre> с сохранением переносов строк"""
        # Находим внутренний тег <pre>, если есть
        inner_pre = pre_tag.find('pre')
        if inner_pre:
            pre_tag = inner_pre
        
        # Создаем копию для обработки, чтобы не изменять оригинал
        pre_copy = pre_tag.__copy__()
        
        # Обрабатываем все элементы внутри pre
        self.process_code_elements(pre_copy)
        
        # Получаем текст с сохранением переносов
        text = pre_copy.get_text()
        
        # Очищаем код
        return self.clean_1c_code(text)
    
    def process_code_elements(self, element):
        """Рекурсивная обработка элементов кода для сохранения переносов строк"""
        children_to_process = list(element.children)  # Создаем копию списка детей
        for child in children_to_process:
            if hasattr(child, 'name') and child.name:
                if child.name == 'font':
                    # Заменяем теги font на их содержимое
                    child.replace_with(child.get_text())
                elif child.name == 'br':
                    # Заменяем <br> на перенос строки
                    child.replace_with('\n')
                else:
                    # Рекурсивно обрабатываем дочерние элементы
                    self.process_code_elements(child)
    
    def clean_1c_code(self, code_text: str) -> str:
        """Очистка кода 1С от лишних символов с сохранением отступов"""
        if not code_text:
            return ""
        
        # Заменяем HTML entities и исправляем кавычки
        code_text = code_text.replace('&quot;', '"')
        code_text = code_text.replace('&lt;', '<')
        code_text = code_text.replace('&gt;', '>')
        code_text = code_text.replace('&amp;', '&')
        # Исправляем двойные кавычки в 1С коде
        code_text = code_text.replace('""', '"')
        
        # ИСПРАВЛЕНИЕ: Нормализуем переносы строк ПЕРЕД разбивкой
        # Заменяем \r\n и \r на \n
        code_text = code_text.replace('\r\n', '\n')
        code_text = code_text.replace('\r', '\n')
        
        lines = []
        for line in code_text.split('\n'):
            # Удаляем только trailing пробелы, но сохраняем отступы в начале
            line = line.rstrip()
            lines.append(line)
        
        # Удаляем лишние пустые строки в начале и в конце
        while lines and not lines[0].strip():
            lines.pop(0)
        while lines and not lines[-1].strip():
            lines.pop()
        
        # Обрабатываем отступы - добавляем стандартный отступ в 4 пробела для всех строк кода
        if lines:
            normalized_lines = []
            for line in lines:
                if line.strip():  # Не пустая строка
                    # Добавляем стандартный отступ в 4 пробела
                    normalized_lines.append('    ' + line.lstrip())
                else:  # Пустая строка
                    normalized_lines.append('')
            lines = normalized_lines
            
        return '\n'.join(lines)
    
    def clean_solution_text(self, text: str) -> str:
        """Очистка текста решения от цифр в скобках в начале"""
        if not text:
            return text
        
        # Удаляем цифры в скобках в начале строки
        text = re.sub(r'^\(\d+\)\s*', '', text.strip())
        
        return text
    
    async def parse_topic(self, session: aiohttp.ClientSession, topic_url: str) -> Optional[List[Dict]]:
        """Парсинг отдельной темы форума"""
        topic_id = self.extract_topic_id(topic_url)
        if not topic_id:
            logger.debug(f"Невалидный URL: {topic_url}")
            return None
            
        logger.info(f"Парсинг темы: {topic_url}")
        
        html = await self.fetch_page(session, topic_url)
        if not html:
            return None
        
        soup = BeautifulSoup(html, 'html.parser')
        
        # Извлекаем метаданные
        meta_id = self.extract_meta_identifier(soup)
        if not meta_id:
            logger.warning(f"Не найден meta identifier для {topic_url}")
            return None
            
        # Проверяем, не обработана ли уже эта тема
        if meta_id in self.processed_urls:
            logger.debug(f"Тема {meta_id} уже обработана")
            return None
        
        # Извлекаем первое сообщение (вопрос)
        question = self.extract_first_message(soup)
        if not question:
            logger.warning(f"Не найден вопрос для {topic_url}")
            return None
        
        # Извлекаем решения
        solutions = self.extract_solutions(soup)
        
        # Создаем записи для каждого решения
        results = []
        if solutions:
            for solution in solutions:
                result = {
                    'source': 'forum_infostart',
                    'in_source_id': meta_id,
                    'prompt': question,
                    'gold_standard_solution': solution
                }
                results.append(result)
        else:
            # Если нет решений, все равно сохраняем вопрос
            result = {
                'source': 'forum_infostart',
                'in_source_id': meta_id,
                'prompt': question,
                'gold_standard_solution': ''
            }
            results.append(result)
        
        self.processed_urls.add(meta_id)
        return results
    
    async def process_topics_batch(self, session: aiohttp.ClientSession, topic_urls: List[str]) -> List[Dict]:
        """Обработка пакета тем с использованием корутин"""
        tasks = [self.parse_topic(session, url) for url in topic_urls]
        results = await asyncio.gather(*tasks, return_exceptions=True)
        
        valid_results = []
        for result in results:
            if isinstance(result, list):
                valid_results.extend(result)
            elif isinstance(result, dict):
                valid_results.append(result)
            elif isinstance(result, Exception):
                logger.error(f"Ошибка при обработке темы: {result}")
        
        return valid_results
    
    def escape_for_csv(self, text: str) -> str:
        """Экранирование специальных символов для CSV"""
        if not text:
            return text
        
        # Экранируем специальные символы для корректного сохранения в CSV
        text = text.replace('\\', '\\\\')   # Экранируем слеши
        text = text.replace('\r\n', '\n')  # Windows переносы -> Unix переносы  
        text = text.replace('\r', '\n')    # Mac переносы -> Unix переносы
        text = text.replace('\n', '\\n')   # Реальные переносы -> литеральные \n
        text = text.replace('\t', '\\t')   # Табуляции -> литеральные \t

        
        return text
    
    def save_to_csv(self, data: List[Dict]):
        """Сохранение данных в CSV файл"""
        if not data:
            return
        
        with open(self.csv_file, 'a', newline='', encoding='utf-8') as file:
            writer = csv.DictWriter(file, fieldnames=['source', 'in_source_id', 'prompt', 'gold_standard_solution'], 
                                  quoting=csv.QUOTE_ALL)  # Полное квотирование для сохранения пробелов
            for row in data:
                # Экранируем специальные символы в текстовых полях
                escaped_row = {}
                for key, value in row.items():
                    if isinstance(value, str):
                        escaped_row[key] = self.escape_for_csv(value)
                    else:
                        escaped_row[key] = value
                writer.writerow(escaped_row)
        
        logger.info(f"Сохранено {len(data)} записей в {self.csv_file}")
    
    async def parse_all_pages(self, start_page: int = 1, end_page: int = 2100, batch_size: int = 10):
        """Парсинг всех страниц форума"""
        connector = aiohttp.TCPConnector(limit=20, limit_per_host=10)
        timeout = aiohttp.ClientTimeout(total=60)
        
        async with aiohttp.ClientSession(
            connector=connector,
            timeout=timeout,
            headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'}
        ) as session:
            
            for page_num in range(start_page, end_page + 1):
                try:
                    logger.info(f"Обработка страницы {page_num} из {end_page}")
                    
                    # Получаем список тем со страницы
                    topic_urls = await self.parse_topic_list_page(session, page_num)
                    
                    if not topic_urls:
                        logger.info(f"Нет тем для обработки на странице {page_num}")
                        continue
                    
                    # Фильтруем уже обработанные темы
                    new_topic_urls = []
                    for url in topic_urls:
                        topic_id = self.extract_topic_id(url)
                        if topic_id and topic_id not in self.processed_urls:
                            new_topic_urls.append(url)
                    
                    logger.info(f"Новых тем для обработки: {len(new_topic_urls)}")
                    
                    if not new_topic_urls:
                        continue
                    
                    # Обрабатываем темы пакетами
                    for i in range(0, len(new_topic_urls), batch_size):
                        batch = new_topic_urls[i:i + batch_size]
                        logger.info(f"Обработка пакета {i//batch_size + 1}, тем в пакете: {len(batch)}")
                        
                        # Парсим пакет тем
                        batch_results = await self.process_topics_batch(session, batch)
                        
                        # Сохраняем результаты
                        if batch_results:
                            self.save_to_csv(batch_results)
                        
                        # Небольшая пауза между пакетами
                        await asyncio.sleep(2)
                    
                    logger.info(f"Страница {page_num} обработана")
                    
                except Exception as e:
                    logger.error(f"Ошибка при обработке страницы {page_num}: {e}")
                    continue

async def main():
    """Основная функция"""
    parser = InfostartForumParser(csv_file='forum_dataset.csv', delay=1.0)
    
    try:
        await parser.parse_all_pages(start_page=1, end_page=2100, batch_size=5)
        logger.info("Парсинг завершен")
    except KeyboardInterrupt:
        logger.info("Парсинг прерван пользователем")
    except Exception as e:
        logger.error(f"Критическая ошибка: {e}")

if __name__ == "__main__":
    asyncio.run(main())