"""
Менеджер публикаций для VK
"""

import os
import logging
import json
from datetime import datetime, timedelta
from typing import Dict, Any, Optional, List
from .vk_client import VKClient
from .config import AppConfig, PostConfig

# Настраиваем логирование
logging.basicConfig(
    level=logging.DEBUG if AppConfig.DEBUG else logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler(f'{AppConfig.LOG_DIR}/post_manager.log', encoding='utf-8'),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

class PostManager:
    """
    Менеджер публикаций VK
    """
    
    def __init__(self, client: Optional[VKClient] = None):
        """
        Инициализация менеджера публикаций
        
        Args:
            client: Клиент VK API (если не указан, создается новый)
        """
        self.client = client or VKClient()
        self.posts_dir = os.path.join(AppConfig.MEDIA_DIR, 'posts')
        
        # Создаем директории, если они не существуют
        os.makedirs(self.posts_dir, exist_ok=True)
        os.makedirs(AppConfig.LOG_DIR, exist_ok=True)
        
        logger.info("PostManager инициализирован")
    
    def _generate_post_id(self) -> str:
        """
        Генерация уникального ID для публикации
        
        Returns:
            Уникальный ID
        """
        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S_%f')
        return f"post_{timestamp}"
    
    def _save_post_draft(self, post_data: Dict[str, Any]) -> str:
        """
        Сохранение черновика публикации
        
        Args:
            post_data: Данные публикации
        
        Returns:
            Путь к файлу черновика
        """
        post_id = post_data.get('post_id', self._generate_post_id())
        post_data['post_id'] = post_id
        post_data['created_at'] = datetime.now().isoformat()
        
        filename = f"{post_id}.json"
        filepath = os.path.join(self.posts_dir, filename)
        
        with open(filepath, 'w', encoding='utf-8') as f:
            json.dump(post_data, f, ensure_ascii=False, indent=2)
        
        logger.info(f"Черновик публикации сохранен: {filepath}")
        return filepath
    
    def _load_post_draft(self, post_id: str) -> Optional[Dict[str, Any]]:
        """
        Загрузка черновика публикации
        
        Args:
            post_id: ID публикации
        
        Returns:
            Данные публикации или None
        """
        filename = f"{post_id}.json"
        filepath = os.path.join(self.posts_dir, filename)
        
        if not os.path.exists(filepath):
            logger.warning(f"Черновик публикации не найден: {filepath}")
            return None
        
        try:
            with open(filepath, 'r', encoding='utf-8') as f:
                post_data = json.load(f)
            logger.info(f"Черновик публикации загружен: {filepath}")
            return post_data
        except Exception as e:
            logger.error(f"Ошибка загрузки черновика публикации: {e}")
            return None
    
    def _format_message(self, title: str, content: str, **kwargs) -> str:
        """
        Форматирование текста публикации
        
        Args:
            title: Заголовок
            content: Основной текст
            **kwargs: Дополнительные параметры
        
        Returns:
            Отформатированный текст
        """
        message = f"{title}\n\n{content}"
        
        # Добавляем хэштеги
        hashtags = kwargs.get('hashtags', [])
        if hashtags:
            message += f"\n\n{' '.join(hashtags)}"
        
        # Добавляем ссылку на сайт
        website = kwargs.get('website')
        if website:
            message += f"\n\n{website}"
        
        # Добавляем контакты
        contacts = kwargs.get('contacts')
        if contacts:
            message += f"\n\n{contacts}"
        
        return message
    
    def _upload_attachments(self, images: List[str] = None, videos: List[str] = None) -> str:
        """
        Загрузка вложений
        
        Args:
            images: Список путей к изображениям
            videos: Список путей к видео
        
        Returns:
            Строка с ID вложений
        """
        attachments = []
        
        # Загружаем изображения
        if images:
            for image_path in images:
                if not os.path.exists(image_path):
                    logger.warning(f"Изображение не найдено: {image_path}")
                    continue
                
                try:
                    response = self.client.upload_photo_to_wall(image_path)
                    if response and 'response' in response and len(response['response']) > 0:
                        photo = response['response'][0]
                        photo_id = f"photo{photo['owner_id']}_{photo['id']}"
                        attachments.append(photo_id)
                        logger.info(f"Изображение загружено: {photo_id}")
                    else:
                        logger.error(f"Не удалось загрузить изображение: {response}")
                except Exception as e:
                    logger.error(f"Ошибка загрузки изображения {image_path}: {e}")
        
        # Загружаем видео (упрощенно, без реальной загрузки)
        if videos:
            for video_path in videos:
                # В реальной реализации нужно использовать video.save и uploads
                logger.warning(f"Загрузка видео пока не реализована: {video_path}")
                # attachments.append(f"video{owner_id}_{video_id}")
        
        return ','.join(attachments) if attachments else ''
    
    def create_post(self,
                   title: str,
                   content: str,
                   images: List[str] = None,
                   videos: List[str] = None,
                   hashtags: List[str] = None,
                   website: str = None,
                   contacts: str = None,
                   **kwargs) -> Dict[str, Any]:
        """
        Создание публикации
        
        Args:
            title: Заголовок публикации
            content: Основной текст
            images: Список путей к изображениям
            videos: Список путей к видео
            hashtags: Список хэштегов
            website: Ссылка на сайт
            contacts: Контактная информация
            **kwargs: Дополнительные параметры для wall.post
        
        Returns:
            Данные публикации
        """
        # Формируем текст
        message = self._format_message(
            title, content,
            hashtags=hashtags,
            website=website,
            contacts=contacts
        )
        
        # Подготавливаем параметры публикации
        post_data = {
            'message': message,
            'from_group': PostConfig.FROM_GROUP,
            'signed': PostConfig.SIGNED,
            'close_comments': PostConfig.CLOSE_COMMENTS,
            **kwargs
        }
        
        # Загружаем вложения
        attachments = self._upload_attachments(images, videos)
        if attachments:
            post_data['attachments'] = attachments
        
        # Сохраняем черновик
        draft_path = self._save_post_draft(post_data)
        
        # Удаляем post_id из данных для отправки в API
        post_data_for_api = post_data.copy()
        if 'post_id' in post_data_for_api:
            del post_data_for_api['post_id']
        if 'created_at' in post_data_for_api:
            del post_data_for_api['created_at']
        
        logger.info(f"Публикация создана: {title}")
        return {
            'post_id': post_data.get('post_id'),
            'message': message,
            'attachments': attachments,
            'draft_path': draft_path,
            'data': post_data_for_api  # Отправляемые данные без post_id
        }
    
    def publish_post(self, post_data: Dict[str, Any]) -> Dict[str, Any]:
        """
        Публикация записи на стене
        
        Args:
            post_data: Данные публикации
        
        Returns:
            Результат публикации
        """
        try:
            result = self.client.publish_post(**post_data)
            
            post_id = result.get('post_id')
            if post_id:
                logger.info(f"Публикация успешно опубликована: post_id={post_id}")
                
                # Обновляем черновик
                if 'post_id' in post_data:
                    draft_data = self._load_post_draft(post_data['post_id'])
                    if draft_data:
                        draft_data['published_at'] = datetime.now().isoformat()
                        draft_data['published_post_id'] = post_id
                        self._save_post_draft(draft_data)
                
                return {
                    'success': True,
                    'post_id': post_id,
                    'result': result
                }
            else:
                logger.error(f"Не удалось опубликовать запись: {result}")
                return {
                    'success': False,
                    'error': 'Не удалось получить ID публикации',
                    'result': result
                }
                
        except Exception as e:
            logger.error(f"Ошибка публикации: {e}")
            return {
                'success': False,
                'error': str(e)
            }
    
    def publish_post_from_draft(self, post_id: str) -> Dict[str, Any]:
        """
        Публикация из черновика
        
        Args:
            post_id: ID черновика
        
        Returns:
            Результат публикации
        """
        draft_data = self._load_post_draft(post_id)
        if not draft_data:
            return {
                'success': False,
                'error': 'Черновик не найден'
            }
        
        return self.publish_post(draft_data)
    
    def schedule_post(self,
                     title: str,
                     content: str,
                     publish_date: datetime,
                     images: List[str] = None,
                     videos: List[str] = None,
                     hashtags: List[str] = None,
                     website: str = None,
                     contacts: str = None,
                     **kwargs) -> Dict[str, Any]:
        """
        Планирование публикации
        
        Args:
            title: Заголовок
            content: Текст
            publish_date: Дата и время публикации
            images: Изображения
            videos: Видео
            hashtags: Хэштеги
            website: Сайт
            contacts: Контакты
            **kwargs: Дополнительные параметры
        
        Returns:
            Результат планирования
        """
        # Создаем публикацию
        post_result = self.create_post(
            title, content, images, videos, hashtags, website, contacts, **kwargs
        )
        
        if not post_result['data']:
            return {
                'success': False,
                'error': 'Не удалось создать публикацию'
            }
        
        # Добавляем дату публикации
        post_data = post_result['data']
        post_data['publish_date'] = int(publish_date.timestamp())
        
        # Планируем публикацию
        try:
            result = self.client.schedule_post(**post_data)
            
            post_id = result.get('post_id')
            if post_id:
                # Обновляем черновик
                draft_data = self._load_post_draft(post_data['post_id'])
                if draft_data:
                    draft_data['scheduled_at'] = publish_date.isoformat()
                    draft_data['scheduled_post_id'] = post_id
                    self._save_post_draft(draft_data)
                
                logger.info(f"Публикация запланирована: {post_id} на {publish_date}")
                return {
                    'success': True,
                    'post_id': post_id,
                    'scheduled_at': publish_date.isoformat(),
                    'result': result
                }
            else:
                logger.error(f"Не удалось запланировать публикацию: {result}")
                return {
                    'success': False,
                    'error': 'Не удалось получить ID публикации',
                    'result': result
                }
                
        except Exception as e:
            logger.error(f"Ошибка планирования публикации: {e}")
            return {
                'success': False,
                'error': str(e)
            }
    
    def get_scheduled_posts(self) -> List[Dict[str, Any]]:
        """
        Получение запланированных публикаций
        
        Returns:
            Список запланированных публикаций
        """
        try:
            response = self.client.get_scheduled_posts()
            
            if 'wall' in response:
                posts = []
                for post in response['wall']:
                    if post.get('post_type') == 'post' and post.get('post_status') == 'scheduled':
                        posts.append({
                            'id': post['id'],
                            'owner_id': post['to_id'],
                            'from_id': post['from_id'],
                            'date': datetime.fromtimestamp(post['date']),
                            'text': post['text'],
                            'attachments': post.get('attachments', []),
                            'post_status': post['post_status']
                        })
                return posts
            
            return []
            
        except Exception as e:
            logger.error(f"Ошибка получения запланированных публикаций: {e}")
            return []
    
    def cancel_scheduled_post(self, post_id: int) -> Dict[str, Any]:
        """
        Отмена запланированной публикации
        
        Args:
            post_id: ID публикации
        
        Returns:
            Результат отмены
        """
        try:
            result = self.client.delete_post(post_id)
            
            if result.get('response') == 1:
                logger.info(f"Запланированная публикация отменена: {post_id}")
                return {
                    'success': True,
                    'result': result
                }
            else:
                logger.error(f"Не удалось отменить публикацию: {result}")
                return {
                    'success': False,
                    'error': 'Не удалось отменить публикацию',
                    'result': result
                }
                
        except Exception as e:
            logger.error(f"Ошибка отмены публикации: {e}")
            return {
                'success': False,
                'error': str(e)
            }
    
    def update_post(self,
                   post_id: int,
                   title: str = None,
                   content: str = None,
                   images: List[str] = None,
                   videos: List[str] = None,
                   **kwargs) -> Dict[str, Any]:
        """
        Обновление публикации
        
        Args:
            post_id: ID публикации
            title: Новый заголовок
            content: Новый текст
            images: Новые изображения
            videos: Новые видео
            **kwargs: Дополнительные параметры
        
        Returns:
            Результат обновления
        """
        try:
            # Получаем текущую публикацию
            posts = self.client.get_wall_posts(count=100)
            current_post = None
            for post in posts.get('wall', []):
                if post['id'] == post_id:
                    current_post = post
                    break
            
            if not current_post:
                return {
                    'success': False,
                    'error': 'Публикация не найдена'
                }
            
            # Формируем новые данные
            update_data = {'post_id': post_id}
            
            if title or content:
                message_parts = []
                if title:
                    message_parts.append(title)
                if content:
                    message_parts.append(content)
                
                message = '\n\n'.join(message_parts)
                update_data['message'] = message
            
            # Обновляем вложения
            if images:
                attachments = self._upload_attachments(images, videos)
                if attachments:
                    update_data['attachments'] = attachments
            
            # Добавляем другие параметры
            update_data.update(kwargs)
            
            result = self.client.edit_post(**update_data)
            
            if result.get('response') == 1:
                logger.info(f"Публикация обновлена: {post_id}")
                return {
                    'success': True,
                    'result': result
                }
            else:
                logger.error(f"Не удалось обновить публикацию: {result}")
                return {
                    'success': False,
                    'error': 'Не удалось обновить публикацию',
                    'result': result
                }
                
        except Exception as e:
            logger.error(f"Ошибка обновления публикации: {e}")
            return {
                'success': False,
                'error': str(e)
            }