# Модели монетизации для Telegram ботов
MONETIZATION_MODELS = {
    'freemium': {
        'description': 'Бесплатные базовые функции + платные премиум',
        'examples': ['Ограниченное количество запросов', 'Базовые функции'],
        'revenue_streams': ['Подписки', 'Разовые платежи']
    },
    'subscription': {
        'description': 'Ежемесячная/годовая подписка',
        'examples': ['Неограниченный доступ', 'Приоритетная поддержка'],
        'revenue_streams': ['Регулярные платежи']
    },
    'pay_per_use': {
        'description': 'Оплата за каждое использование',
        'examples': ['Генерация контента', 'Анализ данных'],
        'revenue_streams': ['Микроплатежи']
    },
    'advertising': {
        'description': 'Реклама в боте',
        'examples': ['Спонсорские сообщения', 'Баннеры'],
        'revenue_streams': ['CPM', 'CPC']
    },
    'marketplace': {
        'description': 'Комиссия с транзакций',
        'examples': ['Продажа товаров', 'Услуги'],
        'revenue_streams': ['Комиссия с продаж']
    }
}

# Факторы выбора модели монетизации
def choose_monetization_model(bot_type, target_audience, features):
    """
    Выбор модели монетизации на основе характеристик бота
    """
    recommendations = {
        'productivity': 'subscription',  # Боты для продуктивности
        'entertainment': 'freemium',     # Развлекательные боты
        'business': 'subscription',     # Бизнес-боты
        'education': 'pay_per_use',     # Образовательные боты
        'ecommerce': 'marketplace',      # Торговые боты
        'news': 'advertising'           # Новостные боты
    }
    
    return recommendations.get(bot_type, 'freemium')

# Интеграция с Telegram Stars
import os
from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import ContextTypes
from telegram.constants import ChatAction

class TelegramStarsHandler:
    def __init__(self, bot_token):
        self.bot_token = bot_token
    
    async def create_stars_invoice(self, update: Update, context: ContextTypes.DEFAULT_TYPE, 
                                 amount: int, title: str, description: str):
        """Создание инвойса для Telegram Stars"""
        try:
            # Создание инвойса
            invoice_data = {
                'title': title,
                'description': description,
                'payload': f'stars_{amount}_{update.effective_user.id}',
                'provider_token': '',  # Для Telegram Stars не нужен
                'currency': 'XTR',     # Telegram Stars
                'prices': [{'label': title, 'amount': amount}],
                'max_tip_amount': amount,
                'suggested_tip_amounts': [amount // 2, amount, amount * 2]
            }
            
            await context.bot.send_invoice(
                chat_id=update.effective_chat.id,
                invoice_data
            )
            
        except Exception as e:
            await update.message.reply_text(f"❌ Ошибка создания инвойса: {e}")
    
    async def handle_pre_payment_checkout(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        """Обработка предварительной проверки платежа"""
        query = update.pre_checkout_query
        
        # Проверка валидности платежа
        if query.invoice_payload.startswith('stars_'):
            await query.answer(ok=True)
        else:
            await query.answer(ok=False, error_message="Неверный тип платежа")
    
    async def handle_successful_payment(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        """Обработка успешного платежа"""
        payment = update.message.successful_payment
        
        # Извлечение данных из payload
        payload_parts = payment.invoice_payload.split('_')
        amount = int(payload_parts[1])
        user_id = int(payload_parts[2])
        
        # Обновление баланса пользователя
        await self.update_user_stars_balance(user_id, amount)
        
        # Отправка подтверждения
        await update.message.reply_text(
            f"✅ Платеж успешно обработан!\n"
            f"💰 Получено: {amount} ⭐\n"
            f"💳 Общий баланс: {await self.get_user_stars_balance(user_id)} ⭐"
        )
    
    async def update_user_stars_balance(self, user_id: int, amount: int):
        """Обновление баланса Telegram Stars пользователя"""
        # Здесь должна быть логика обновления в базе данных
        pass
    
    async def get_user_stars_balance(self, user_id: int) -> int:
        """Получение баланса Telegram Stars пользователя"""
        # Здесь должна быть логика получения из базы данных
        return 0

# Пример использования
async def buy_premium_subscription(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Покупка премиум подписки"""
    stars_handler = TelegramStarsHandler(os.getenv('BOT_TOKEN'))
    
    await stars_handler.create_stars_invoice(
        update=update,
        context=context,
        amount=100,  # 100 Telegram Stars
        title="Премиум подписка на месяц",
        description="Доступ к премиум функциям на 30 дней"
    )

# Интеграция с ЮKassa
import requests
import hashlib
import hmac
import json
from datetime import datetime

class YooKassaHandler:
    def __init__(self, shop_id, secret_key):
        self.shop_id = shop_id
        self.secret_key = secret_key
        self.base_url = "https://api.yookassa.ru/v3"
    
    def create_payment(self, amount, currency, description, user_id):
        """Создание платежа через ЮKassa"""
        payment_data = {
            "amount": {
                "value": str(amount),
                "currency": currency
            },
            "confirmation": {
                "type": "redirect",
                "return_url": f"https://yourbot.com/payment/success"
            },
            "description": description,
            "metadata": {
                "user_id": str(user_id),
                "bot_payment": "true"
            }
        }
        
        headers = {
            "Authorization": f"Basic {self._get_auth_header()}",
            "Content-Type": "application/json",
            "Idempotence-Key": f"{user_id}_{int(datetime.now().timestamp())}"
        }
        
        response = requests.post(
            f"{self.base_url}/payments",
            headers=headers,
            data=json.dumps(payment_data)
        )
        
        if response.status_code == 200:
            return response.json()
        else:
            raise Exception(f"Ошибка создания платежа: {response.text}")
    
    def verify_webhook(self, request_body, signature):
        """Проверка подписи webhook от ЮKassa"""
        expected_signature = hmac.new(
            self.secret_key.encode(),
            request_body.encode(),
            hashlib.sha256
        ).hexdigest()
        
        return hmac.compare_digest(signature, expected_signature)
    
    def _get_auth_header(self):
        """Получение заголовка авторизации"""
        import base64
        auth_string = f"{self.shop_id}:{self.secret_key}"
        return base64.b64encode(auth_string.encode()).decode()

# Обработчик платежей в боте
async def handle_yookassa_payment(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Обработка платежа через ЮKassa"""
    yookassa = YooKassaHandler(
        shop_id=os.getenv('YOOKASSA_SHOP_ID'),
        secret_key=os.getenv('YOOKASSA_SECRET_KEY')
    )
    
    try:
        # Создание платежа
        payment = yookassa.create_payment(
            amount=1000,  # 1000 рублей
            currency="RUB",
            description="Премиум подписка на месяц",
            user_id=update.effective_user.id
        )
        
        # Отправка ссылки на оплату
        payment_url = payment['confirmation']['confirmation_url']
        
        keyboard = [
            [InlineKeyboardButton("💳 Оплатить", url=payment_url)],
            [InlineKeyboardButton("❌ Отмена", callback_data="cancel_payment")]
        ]
        reply_markup = InlineKeyboardMarkup(keyboard)
        
        await update.message.reply_text(
            "💳 Для оплаты премиум подписки перейдите по ссылке:",
            reply_markup=reply_markup
        )
        
    except Exception as e:
        await update.message.reply_text(f"❌ Ошибка создания платежа: {e}")

# Интеграция со Stripe
import stripe
from telegram import InlineKeyboardButton, InlineKeyboardMarkup

class StripeHandler:
    def __init__(self, secret_key):
        stripe.api_key = secret_key
    
    def create_payment_intent(self, amount, currency, user_id):
        """Создание Payment Intent в Stripe"""
        try:
            intent = stripe.PaymentIntent.create(
                amount=amount,  # В центах
                currency=currency,
                metadata={
                    'user_id': str(user_id),
                    'bot_payment': 'true'
                }
            )
            return intent
        except Exception as e:
            raise Exception(f"Ошибка создания Payment Intent: {e}")
    
    def create_checkout_session(self, amount, currency, success_url, cancel_url, user_id):
        """Создание Checkout Session"""
        try:
            session = stripe.checkout.Session.create(
                payment_method_types=['card'],
                line_items=[{
                    'price_data': {
                        'currency': currency,
                        'product_data': {
                            'name': 'Премиум подписка',
                        },
                        'unit_amount': amount,
                    },
                    'quantity': 1,
                }],
                mode='payment',
                success_url=success_url,
                cancel_url=cancel_url,
                metadata={
                    'user_id': str(user_id)
                }
            )
            return session
        except Exception as e:
            raise Exception(f"Ошибка создания Checkout Session: {e}")

# Обработчик Stripe платежей
async def handle_stripe_payment(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Обработка платежа через Stripe"""
    stripe_handler = StripeHandler(os.getenv('STRIPE_SECRET_KEY'))
    
    try:
        # Создание Checkout Session
        session = stripe_handler.create_checkout_session(
            amount=1000,  # $10.00
            currency='usd',
            success_url='https://yourbot.com/payment/success',
            cancel_url='https://yourbot.com/payment/cancel',
            user_id=update.effective_user.id
        )
        
        # Отправка ссылки на оплату
        keyboard = [
            [InlineKeyboardButton("💳 Оплатить", url=session.url)],
            [InlineKeyboardButton("❌ Отмена", callback_data="cancel_payment")]
        ]
        reply_markup = InlineKeyboardMarkup(keyboard)
        
        await update.message.reply_text(
            "💳 Для оплаты премиум подписки перейдите по ссылке:",
            reply_markup=reply_markup
        )
        
    except Exception as e:
        await update.message.reply_text(f"❌ Ошибка создания платежа: {e}")

# Модель подписки в базе данных
from sqlalchemy import Column, Integer, String, DateTime, Boolean, Float, Text
from sqlalchemy.ext.declarative import declarative_base
from datetime import datetime, timedelta
import json

Base = declarative_base()

class Subscription(Base):
    """Модель подписки"""
    __tablename__ = 'subscriptions'
    
    id = Column(Integer, primary_key=True)
    user_id = Column(Integer, nullable=False)
    subscription_type = Column(String(50), nullable=False)  # basic, premium, pro
    status = Column(String(20), default='active')  # active, expired, cancelled
    start_date = Column(DateTime, default=datetime.utcnow)
    end_date = Column(DateTime, nullable=False)
    auto_renew = Column(Boolean, default=True)
    payment_method = Column(String(50), nullable=True)  # stars, yookassa, stripe
    amount_paid = Column(Float, nullable=False)
    currency = Column(String(3), default='RUB')
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)

class SubscriptionPlan(Base):
    """Модель плана подписки"""
    __tablename__ = 'subscription_plans'
    
    id = Column(Integer, primary_key=True)
    name = Column(String(100), nullable=False)
    description = Column(Text, nullable=True)
    price = Column(Float, nullable=False)
    currency = Column(String(3), default='RUB')
    duration_days = Column(Integer, nullable=False)
    features = Column(Text, nullable=True)  # JSON список функций
    is_active = Column(Boolean, default=True)
    created_at = Column(DateTime, default=datetime.utcnow)

class Payment(Base):
    """Модель платежа"""
    __tablename__ = 'payments'
    
    id = Column(Integer, primary_key=True)
    user_id = Column(Integer, nullable=False)
    subscription_id = Column(Integer, nullable=True)
    amount = Column(Float, nullable=False)
    currency = Column(String(3), default='RUB')
    payment_method = Column(String(50), nullable=False)
    payment_id = Column(String(255), nullable=True)  # ID от платежной системы
    status = Column(String(20), default='pending')  # pending, completed, failed, refunded
    created_at = Column(DateTime, default=datetime.utcnow)
    completed_at = Column(DateTime, nullable=True)

# Сервис управления подписками
from sqlalchemy.orm import Session
from datetime import datetime, timedelta
import json

class SubscriptionService:
    def __init__(self, db: Session):
        self.db = db
    
    def create_subscription(self, user_id: int, plan_id: int, payment_id: str = None):
        """Создание новой подписки"""
        plan = self.db.query(SubscriptionPlan).filter_by(id=plan_id).first()
        if not plan:
            raise ValueError("План подписки не найден")
        
        # Проверка активной подписки
        existing_subscription = self.get_active_subscription(user_id)
        if existing_subscription:
            # Продление существующей подписки
            existing_subscription.end_date += timedelta(days=plan.duration_days)
            existing_subscription.updated_at = datetime.utcnow()
            subscription = existing_subscription
        else:
            # Создание новой подписки
            subscription = Subscription(
                user_id=user_id,
                subscription_type=plan.name,
                end_date=datetime.utcnow() + timedelta(days=plan.duration_days),
                amount_paid=plan.price,
                currency=plan.currency,
                payment_method='stars'  # По умолчанию
            )
            self.db.add(subscription)
        
        # Создание записи о платеже
        if payment_id:
            payment = Payment(
                user_id=user_id,
                subscription_id=subscription.id,
                amount=plan.price,
                currency=plan.currency,
                payment_method='stars',
                payment_id=payment_id,
                status='completed',
                completed_at=datetime.utcnow()
            )
            self.db.add(payment)
        
        self.db.commit()
        return subscription
    
    def get_active_subscription(self, user_id: int):
        """Получение активной подписки пользователя"""
        return self.db.query(Subscription).filter(
            Subscription.user_id == user_id,
            Subscription.status == 'active',
            Subscription.end_date > datetime.utcnow()
        ).first()
    
    def check_subscription_access(self, user_id: int, feature: str):
        """Проверка доступа к функции"""
        subscription = self.get_active_subscription(user_id)
        if not subscription:
            return False
        
        plan = self.db.query(SubscriptionPlan).filter_by(name=subscription.subscription_type).first()
        if not plan:
            return False
        
        features = json.loads(plan.features) if plan.features else []
        return feature in features
    
    def cancel_subscription(self, user_id: int):
        """Отмена подписки"""
        subscription = self.get_active_subscription(user_id)
        if subscription:
            subscription.status = 'cancelled'
            subscription.auto_renew = False
            subscription.updated_at = datetime.utcnow()
            self.db.commit()
            return True
        return False
    
    def get_subscription_plans(self):
        """Получение доступных планов подписки"""
        return self.db.query(SubscriptionPlan).filter_by(is_active=True).all()
    
    def get_user_subscription_history(self, user_id: int):
        """История подписок пользователя"""
        return self.db.query(Subscription).filter_by(user_id=user_id).order_by(
            Subscription.created_at.desc()
        ).all()

# Команды для работы с подписками
from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import ContextTypes

async def subscription_menu(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Меню подписок"""
    db = next(get_db())
    subscription_service = SubscriptionService(db)
    
    # Получение текущей подписки
    current_subscription = subscription_service.get_active_subscription(update.effective_user.id)
    
    if current_subscription:
        # Пользователь уже имеет подписку
        end_date = current_subscription.end_date.strftime('%d.%m.%Y')
        subscription_text = f"""
💎 Ваша подписка

📦 План: {current_subscription.subscription_type}
📅 Действует до: {end_date}
🔄 Автопродление: {'Да' if current_subscription.auto_renew else 'Нет'}
        """
        
        keyboard = [
            [InlineKeyboardButton("📊 Статистика", callback_data="subscription_stats")],
            [InlineKeyboardButton("❌ Отменить подписку", callback_data="cancel_subscription")],
            [InlineKeyboardButton("🔙 Назад", callback_data="back_main")]
        ]
    else:
        # Пользователь без подписки
        subscription_text = """
💎 Премиум подписки

Выберите подходящий план для доступа к премиум функциям:
        """
        
        # Получение доступных планов
        plans = subscription_service.get_subscription_plans()
        keyboard = []
        
        for plan in plans:
            keyboard.append([
                InlineKeyboardButton(
                    f"💎 {plan.name} - {plan.price} {plan.currency}",
                    callback_data=f"subscribe_{plan.id}"
                )
            ])
        
        keyboard.append([InlineKeyboardButton("🔙 Назад", callback_data="back_main")])
    
    reply_markup = InlineKeyboardMarkup(keyboard)
    await update.message.reply_text(subscription_text, parse_mode='Markdown', reply_markup=reply_markup)

async def handle_subscription_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Обработка callback-запросов подписок"""
    query = update.callback_query
    await query.answer()
    
    if query.data.startswith('subscribe_'):
        plan_id = int(query.data.split('_')[1])
        await show_subscription_plan(update, context, plan_id)
    elif query.data == 'cancel_subscription':
        await cancel_subscription_confirmation(update, context)
    elif query.data == 'subscription_stats':
        await show_subscription_stats(update, context)

async def show_subscription_plan(update: Update, context: ContextTypes.DEFAULT_TYPE, plan_id: int):
    """Показ плана подписки"""
    db = next(get_db())
    subscription_service = SubscriptionService(db)
    
    plan = subscription_service.db.query(SubscriptionPlan).filter_by(id=plan_id).first()
    if not plan:
        await query.edit_message_text("❌ План подписки не найден!")
        return
    
    features = json.loads(plan.features) if plan.features else []
    features_text = "\n".join([f"✅ {feature}" for feature in features])
    
    plan_text = f"""
💎 {plan.name}

💰 Цена: {plan.price} {plan.currency}
📅 Длительность: {plan.duration_days} дней
📝 Описание: {plan.description}

🎯 Включенные функции:
{features_text}
    """
    
    keyboard = [
        [InlineKeyboardButton("💳 Оплатить", callback_data=f"pay_{plan_id}")],
        [InlineKeyboardButton("🔙 Назад", callback_data="subscription_menu")]
    ]
    reply_markup = InlineKeyboardMarkup(keyboard)
    
    await query.edit_message_text(plan_text, parse_mode='Markdown', reply_markup=reply_markup)

# Система ограничений для премиум функций
class FeatureLimiter:
    def __init__(self, db: Session):
        self.db = db
        self.subscription_service = SubscriptionService(db)
    
    async def check_rate_limit(self, user_id: int, feature: str, limit: int):
        """Проверка лимита использования функции"""
        # Проверка подписки
        subscription = self.subscription_service.get_active_subscription(user_id)
        if subscription:
            # Премиум пользователи имеют увеличенные лимиты
            limit *= 5
        
        # Проверка использования за сегодня
        today = datetime.now().date()
        usage_count = self.db.execute(db.text("""
            SELECT COUNT(*) FROM feature_usage 
            WHERE user_id = :user_id 
            AND feature = :feature 
            AND DATE(used_at) = :today
        """), {
            'user_id': user_id,
            'feature': feature,
            'today': today
        }).scalar()
        
        return usage_count < limit
    
    async def record_feature_usage(self, user_id: int, feature: str):
        """Запись использования функции"""
        self.db.execute(db.text("""
            INSERT INTO feature_usage (user_id, feature, used_at)
            VALUES (:user_id, :feature, :now)
        """), {
            'user_id': user_id,
            'feature': feature,
            'now': datetime.utcnow()
        })
        self.db.commit()

# Декоратор для проверки премиум доступа
def premium_required(feature_name: str):
    """Декоратор для проверки премиум доступа"""
    def decorator(func):
        async def wrapper(update: Update, context: ContextTypes.DEFAULT_TYPE):
            user_id = update.effective_user.id
            db = next(get_db())
            subscription_service = SubscriptionService(db)
            
            # Проверка доступа к функции
            if not subscription_service.check_subscription_access(user_id, feature_name):
                await update.message.reply_text(
                    f"🔒 Эта функция доступна только премиум пользователям!\n\n"
                    f"💎 Оформите подписку для доступа к {feature_name}",
                    reply_markup=InlineKeyboardMarkup([[
                        InlineKeyboardButton("💎 Оформить подписку", callback_data="subscription_menu")
                    ]])
                )
                return
            
            return await func(update, context)
        return wrapper
    return decorator

# Примеры премиум функций
@premium_required("unlimited_requests")
async def unlimited_ai_request(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Неограниченные AI запросы для премиум пользователей"""
    # Логика обработки AI запроса
    await update.message.reply_text("🤖 AI запрос обработан!")

@premium_required("advanced_analytics")
async def advanced_analytics(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Расширенная аналитика для премиум пользователей"""
    # Логика аналитики
    await update.message.reply_text("📊 Расширенная аналитика готова!")

# Аналитика доходов
class RevenueAnalytics:
    def __init__(self, db: Session):
        self.db = db
    
    def get_daily_revenue(self, days: int = 30):
        """Доходы по дням"""
        return self.db.execute(db.text("""
            SELECT 
                DATE(completed_at) as date,
                SUM(amount) as revenue,
                COUNT(*) as transactions
            FROM payments 
            WHERE status = 'completed' 
            AND completed_at >= NOW() - INTERVAL :days DAY
            GROUP BY DATE(completed_at)
            ORDER BY date
        """), {'days': days}).fetchall()
    
    def get_subscription_revenue(self):
        """Доходы от подписок"""
        return self.db.execute(db.text("""
            SELECT 
                subscription_type,
                COUNT(*) as subscriptions,
                SUM(amount_paid) as revenue
            FROM subscriptions 
            WHERE status = 'active'
            GROUP BY subscription_type
        """)).fetchall()
    
    def get_payment_method_stats(self):
        """Статистика по методам платежа"""
        return self.db.execute(db.text("""
            SELECT 
                payment_method,
                COUNT(*) as transactions,
                SUM(amount) as revenue
            FROM payments 
            WHERE status = 'completed'
            GROUP BY payment_method
        """)).fetchall()
    
    def get_user_lifetime_value(self, user_id: int):
        """Стоимость пользователя за все время"""
        result = self.db.execute(db.text("""
            SELECT 
                SUM(amount) as total_spent,
                COUNT(*) as total_transactions,
                MIN(completed_at) as first_payment,
                MAX(completed_at) as last_payment
            FROM payments 
            WHERE user_id = :user_id 
            AND status = 'completed'
        """), {'user_id': user_id}).fetchone()
        
        return result

# API для аналитики доходов
@api_bp.route('/analytics/revenue')
@admin_required
def api_revenue_analytics():
    """API аналитики доходов"""
    db = next(get_db())
    analytics = RevenueAnalytics(db)
    
    # Данные за последние 30 дней
    daily_revenue = analytics.get_daily_revenue(30)
    subscription_revenue = analytics.get_subscription_revenue()
    payment_methods = analytics.get_payment_method_stats()
    
    return jsonify({
        'daily_revenue': [dict(row._mapping) for row in daily_revenue],
        'subscription_revenue': [dict(row._mapping) for row in subscription_revenue],
        'payment_methods': [dict(row._mapping) for row in payment_methods]
    })

# Юридические аспекты монетизации
LEGAL_REQUIREMENTS = {
    'taxes': {
        'description': 'Налогообложение доходов от ботов',
        'requirements': [
            'Регистрация ИП или ООО',
            'Ведение учета доходов и расходов',
            'Уплата налогов (НДФЛ, НДС)',
            'Отчетность в налоговую'
        ]
    },
    'data_protection': {
        'description': 'Защита персональных данных',
        'requirements': [
            'Согласие на обработку данных',
            'Политика конфиденциальности',
            'Соответствие GDPR/152-ФЗ',
            'Безопасное хранение данных'
        ]
    },
    'terms_of_service': {
        'description': 'Пользовательское соглашение',
        'requirements': [
            'Условия использования бота',
            'Правила возврата средств',
            'Ограничение ответственности',
            'Интеллектуальная собственность'
        ]
    },
    'payment_compliance': {
        'description': 'Соответствие платежным системам',
        'requirements': [
            'PCI DSS для карточных платежей',
            'KYC/AML процедуры',
            'Мониторинг подозрительных транзакций',
            'Соответствие местному законодательству'
        ]
    }
}

# Шаблон пользовательского соглашения
TERMS_OF_SERVICE_TEMPLATE = """
ПОЛЬЗОВАТЕЛЬСКОЕ СОГЛАШЕНИЕ

ОБЩИЕ ПОЛОЖЕНИЯ

1.1. Настоящее Соглашение регулирует отношения между пользователем и администрацией бота.

УСЛУГИ БОТА

2.1. Бот предоставляет следующие услуги:
Базовые функции (бесплатно)

Премиум функции (платно)


ОПЛАТА И ВОЗВРАТ

3.1. Оплата производится через Telegram Stars или другие платежные системы.
3.2. Возврат средств возможен в течение 14 дней с момента покупки.

ЗАЩИТА ДАННЫХ

4.1. Мы защищаем ваши персональные данные в соответствии с законодательством РФ.

ОГРАНИЧЕНИЕ ОТВЕТСТВЕННОСТИ

5.1. Мы не несем ответственности за ущерб, причиненный использованием бота.
"""

# Генерация политики конфиденциальности
def generate_privacy_policy(bot_name: str, contact_email: str):
    """Генерация политики конфиденциальности"""
    return f"""
ПОЛИТИКА КОНФИДЕНЦИАЛЬНОСТИ

СБОР ДАННЫХ

Мы собираем следующие данные:
Telegram ID пользователя

Имя пользователя

История сообщений

Данные платежей


ИСПОЛЬЗОВАНИЕ ДАННЫХ

Данные используются для:
Предоставления услуг бота

Обработки платежей

Улучшения функциональности


ЗАЩИТА ДАННЫХ

Мы применяем следующие меры защиты:
Шифрование данных

Ограничение доступа

Регулярные проверки безопасности


КОНТАКТЫ

По вопросам защиты данных обращайтесь: {contact_email}
"""