main.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Vergi Hatırlatıcı Bot - Ana Uygulama
GİB vergi güncellemelerini Telegram üzerinden kullanıcılara ileten bot
"""

import os
import sys
import asyncio
import logging
from datetime import datetime
import schedule
import time
from threading import Thread
from dotenv import load_dotenv

# Local imports
from bot import VergiBot
from database import DatabaseConnection
from scraper import GIBScraper

# .env dosyasını yükle
load_dotenv()

class VergiHatirlaticiApp:
    """Ana uygulama sınıfı"""
    
    def __init__(self):
        self.bot_token = os.getenv('BOT_TOKEN')
        self.db = None
        self.bot = None
        self.logger = self.setup_logging()
        
        # Uygulama başlangıç kontrolü
        self.check_requirements()
        
    def setup_logging(self):
        """Logging yapılandırması"""
        # logs klasörünü oluştur
        if not os.path.exists('logs'):
            os.makedirs('logs')
            
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('logs/main.log', encoding='utf-8'),
                logging.StreamHandler()
            ]
        )
        return logging.getLogger(__name__)
        
    def check_requirements(self):
        """Gereksinimler kontrolü"""
        try:
            # Bot token kontrolü
            if not self.bot_token:
                raise ValueError("BOT_TOKEN bulunamadı! .env dosyasını kontrol edin.")
                
            # Veritabanı bağlantı kontrolü
            self.db = DatabaseConnection()
            self.db.connect()
            self.logger.info("✅ Veritabanı bağlantısı başarılı")
            
            # Gerekli tabloları oluştur
            self.create_tables()
            
            self.logger.info("✅ Tüm gereksinimler karşılandı")
            
        except Exception as e:
            self.logger.error(f"❌ Gereksinim kontrolü başarısız: {str(e)}")
            sys.exit(1)
            
    def create_tables(self):
        """Veritabanı tablolarını oluştur"""
        try:
            # Users tablosu - reminder_days sütunu eklendi
            self.db.execute_query("""
                CREATE TABLE IF NOT EXISTS users (
                    user_id BIGINT PRIMARY KEY,
                    username VARCHAR(255),
                    chat_id BIGINT UNIQUE,
                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                    is_active BOOLEAN DEFAULT TRUE,
                    reminder_days INT DEFAULT NULL
                )
            """)
            
            # Tax calendar tablosu
            self.db.execute_query("""
                CREATE TABLE IF NOT EXISTS tax_calendar (
                    id INT AUTO_INCREMENT PRIMARY KEY,
                    tax_type VARCHAR(255) NOT NULL,
                    deadline_date DATE NOT NULL,
                    description TEXT,
                    source VARCHAR(255) DEFAULT 'GİB',
                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
                    INDEX idx_deadline_date (deadline_date)
                )
            """)
            
            # Announcements tablosu
            self.db.execute_query("""
                CREATE TABLE IF NOT EXISTS announcements (
                    id INT AUTO_INCREMENT PRIMARY KEY,
                    title VARCHAR(500) NOT NULL,
                    content TEXT,
                    url VARCHAR(500),
                    source VARCHAR(255) DEFAULT 'GİB',
                    category VARCHAR(100),
                    published_date DATETIME,
                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                    INDEX idx_published_date (published_date),
                    INDEX idx_source (source)
                )
            """)
            
            # Reminders tablosu
            self.db.execute_query("""
                CREATE TABLE IF NOT EXISTS reminders (
                    id INT AUTO_INCREMENT PRIMARY KEY,
                    user_id BIGINT,
                    tax_calendar_id INT,
                    reminder_date DATETIME,
                    is_sent BOOLEAN DEFAULT FALSE,
                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                    FOREIGN KEY (user_id) REFERENCES users(user_id) ON DELETE CASCADE,
                    FOREIGN KEY (tax_calendar_id) REFERENCES tax_calendar(id) ON DELETE CASCADE,
                    INDEX idx_reminder_date (reminder_date),
                    INDEX idx_is_sent (is_sent)
                )
            """)
            
            self.logger.info("✅ Veritabanı tabloları hazır")
            
        except Exception as e:
            self.logger.error(f"❌ Tablo oluşturma hatası: {str(e)}")
            raise
            
    def initialize_bot(self):
        """Bot'u başlat"""
        try:
            self.bot = VergiBot(self.bot_token)
            self.logger.info("✅ Bot başarıyla oluşturuldu")
            return True
            
        except Exception as e:
            self.logger.error(f"❌ Bot başlatma hatası: {str(e)}")
            return False
            
    def schedule_tasks(self):
        """Zamanlanmış görevleri ayarla"""
        try:
            # Her gün saat 09:00'da veri güncelleme
            schedule.every().day.at("09:00").do(self.daily_data_update)
            
            # Her gün saat 08:00'de hatırlatma kontrolü
            schedule.every().day.at("08:00").do(self.send_reminders)
            
            # Her 6 saatte bir sistem sağlık kontrolü
            schedule.every(6).hours.do(self.health_check)
            
            self.logger.info("✅ Zamanlanmış görevler ayarlandı")
            
        except Exception as e:
            self.logger.error(f"❌ Görev zamanlama hatası: {str(e)}")
            
    def daily_data_update(self):
        """Günlük veri güncelleme"""
        try:
            self.logger.info("🔄 Günlük veri güncelleme başlatılıyor...")
            
            scraper = GIBScraper()
            updates = scraper.get_all_updates()
            
            # Duyuruları veritabanına kaydet
            if updates['announcements']:
                for announcement in updates['announcements']:
                    try:
                        self.db.execute_query("""
                            INSERT IGNORE INTO announcements (title, content, url, source, category, published_date) 
                            VALUES (%s, %s, %s, %s, %s, %s)
                        """, (
                            announcement['title'],
                            announcement.get('content', ''),
                            announcement.get('url', ''),
                            announcement.get('source', 'GİB'),
                            announcement.get('category', 'Duyuru'),
                            announcement.get('date', datetime.now())
                        ))
                    except Exception as e:
                        self.logger.error(f"Duyuru kaydetme hatası: {str(e)}")
                        continue
                        
            # Vergi takvimini güncelle
            if updates['calendar']:
                for tax_event in updates['calendar']:
                    try:
                        self.db.execute_query("""
                            INSERT INTO tax_calendar (tax_type, deadline_date, description, source) 
                            VALUES (%s, %s, %s, %s)
                            ON DUPLICATE KEY UPDATE 
                            description = VALUES(description),
                            updated_at = CURRENT_TIMESTAMP
                        """, (
                            tax_event['tax_type'],
                            tax_event['deadline_date'],
                            tax_event.get('description', ''),
                            tax_event.get('source', 'GİB')
                        ))
                    except Exception as e:
                        self.logger.error(f"Takvim kaydetme hatası: {str(e)}")
                        continue
                        
            scraper.close()
            self.logger.info("✅ Günlük veri güncelleme tamamlandı")
            
        except Exception as e:
            self.logger.error(f"❌ Günlük veri güncelleme hatası: {str(e)}")
            
    def send_reminders(self):
        """Zamanlanmış hatırlatmaları gönder"""
        try:
            if self.bot:
                asyncio.create_task(self.bot.send_scheduled_reminders())
                self.logger.info("✅ Hatırlatmalar gönderildi")
        except Exception as e:
            self.logger.error(f"❌ Hatırlatma gönderme hatası: {str(e)}")
            
    def health_check(self):
        """Sistem sağlık kontrolü"""
        try:
            # Veritabanı kontrolü
            self.db.execute_query("SELECT 1")
            
            # Bot durumu kontrolü
            if not self.bot:
                self.logger.warning("⚠️ Bot bağlantısı kopuk")
                
            self.logger.info("✅ Sistem sağlık kontrolü başarılı")
            
        except Exception as e:
            self.logger.error(f"❌ Sistem sağlık kontrolü hatası: {str(e)}")
            
    def run_scheduler(self):
        """Zamanlanmış görevleri çalıştır"""
        while True:
            try:
                schedule.run_pending()
                time.sleep(60)  # Her dakika kontrol et
            except KeyboardInterrupt:
                self.logger.info("🛑 Zamanlayıcı durduruldu")
                break
            except Exception as e:
                self.logger.error(f"❌ Zamanlayıcı hatası: {str(e)}")
                time.sleep(60)
                
    def run(self):
        """Ana uygulama çalıştır"""
        try:
            self.logger.info("🚀 Vergi Hatırlatıcı Bot başlatılıyor...")
            
            # Bot'u başlat
            if not self.initialize_bot():
                self.logger.error("❌ Bot başlatılamadı!")
                return
                
            # Zamanlanmış görevleri ayarla
            self.schedule_tasks()
            
            # İlk veri güncellemeyi yap
            self.daily_data_update()
            
            # Zamanlayıcıyı ayrı thread'de çalıştır
            scheduler_thread = Thread(target=self.run_scheduler, daemon=True)
            scheduler_thread.start()
            self.logger.info("✅ Zamanlayıcı thread'i başlatıldı")
            
            # Bot'u çalıştır
            self.logger.info("🤖 Telegram Bot çalıştırılıyor...")
            self.logger.info(f"Bot kullanıma hazır: @VergiHatirlaticiBot")
            
            # Bot'u başlat
            self.bot.app.run_polling(
                drop_pending_updates=True,
                allowed_updates=['message', 'callback_query']
            )
            
        except KeyboardInterrupt:
            self.logger.info("🛑 Uygulama kullanıcı tarafından durduruldu")
        except Exception as e:
            self.logger.error(f"❌ Ana uygulama hatası: {str(e)}")
        finally:
            self.cleanup()
            
    def cleanup(self):
        """Kaynakları temizle"""
        try:
            if self.bot:
                self.bot.scraper.close()
            if self.db:
                self.db.close_connection()
            self.logger.info("✅ Kaynaklar temizlendi")
        except Exception as e:
            self.logger.error(f"❌ Cleanup hatası: {str(e)}")

def print_startup_info():
    """Başlangıç bilgilerini göster"""
    print("=" * 60)
    print("🏛️  VERGİ HATIRLATICI BOT")
    print("=" * 60)
    print("📋 Özellikler:")
    print("   • GİB vergi güncellemeleri")
    print("   • Otomatik vergi takvimi")
    print("   • Hatırlatma sistemi")
    print("   • 7/24 çalışma")
    print()
    print("🔧 Sistem Gereksinimleri:")
    print("   • Python 3.8+")
    print("   • MySQL 8.0+")
    print("   • Internet bağlantısı")
    print()
    print("📞 Bot Bilgileri:")
    print("   • Ad: VergiHatirlaticiBot")
    print("   • Link: t.me/VergiHatirlaticiBot")
    print("=" * 60)
    print()

def main():
    """Ana fonksiyon"""
    try:
        # Başlangıç bilgilerini göster
        print_startup_info()
        
        # Uygulamayı başlat
        app = VergiHatirlaticiApp()
        app.run()
        
    except Exception as e:
        logging.error(f"❌ Program başlatma hatası: {str(e)}")
        sys.exit(1)

if __name__ == "__main__":
    main()