#!/usr/bin/env python3
"""
30-Day Sovereignty DCA Bot - GUI Version
Desktop application with real-time monitoring
"""

import sys
from PyQt5.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout,
                             QHBoxLayout, QPushButton, QLabel, QTableWidget,
                             QTableWidgetItem, QTextEdit, QGroupBox, QLineEdit,
                             QMessageBox, QTabWidget)
from PyQt5.QtCore import QTimer, Qt
from PyQt5.QtGui import QFont, QColor
import pyqtgraph as pg
from dca_bot import DCABot
from datetime import datetime
import logging

class DCABotGUI(QMainWindow):
    """GUI for DCA Bot"""

    def __init__(self):
        super().__init__()
        self.bot = None
        self.is_running = False
        self.init_ui()
        self.setup_timer()

    def init_ui(self):
        """Initialize UI"""
        self.setWindowTitle('30-Day Sovereignty DCA Bot')
        self.setGeometry(100, 100, 1200, 800)

        # Central widget
        central_widget = QWidget()
        self.setCentralWidget(central_widget)

        # Main layout
        main_layout = QVBoxLayout()
        central_widget.setLayout(main_layout)

        # Title
        title = QLabel('30-DAY SOVEREIGNTY DCA BOT')
        title.setFont(QFont('Arial', 18, QFont.Bold))
        title.setAlignment(Qt.AlignCenter)
        title.setStyleSheet('color: #f7931a; padding: 10px;')
        main_layout.addWidget(title)

        # Tabs
        tabs = QTabWidget()
        main_layout.addWidget(tabs)

        # Dashboard tab
        dashboard_tab = self.create_dashboard_tab()
        tabs.addTab(dashboard_tab, '📊 Dashboard')

        # Transactions tab
        transactions_tab = self.create_transactions_tab()
        tabs.addTab(transactions_tab, '💰 Transactions')

        # Logs tab
        logs_tab = self.create_logs_tab()
        tabs.addTab(logs_tab, '📋 Logs')

        # Settings tab
        settings_tab = self.create_settings_tab()
        tabs.addTab(settings_tab, '⚙️ Settings')

        # Status bar
        self.statusBar().showMessage('Bot not initialized')

    def create_dashboard_tab(self):
        """Create dashboard tab"""
        widget = QWidget()
        layout = QVBoxLayout()
        widget.setLayout(layout)

        # Control buttons
        controls_layout = QHBoxLayout()

        self.start_btn = QPushButton('▶️ Start Bot')
        self.start_btn.clicked.connect(self.start_bot)
        self.start_btn.setStyleSheet('background-color: #28a745; color: white; padding: 10px; font-size: 14px;')
        controls_layout.addWidget(self.start_btn)

        self.stop_btn = QPushButton('⏹️ Stop Bot')
        self.stop_btn.clicked.connect(self.stop_bot)
        self.stop_btn.setEnabled(False)
        self.stop_btn.setStyleSheet('background-color: #dc3545; color: white; padding: 10px; font-size: 14px;')
        controls_layout.addWidget(self.stop_btn)

        self.execute_btn = QPushButton('💸 Execute Once')
        self.execute_btn.clicked.connect(self.execute_once)
        self.execute_btn.setStyleSheet('background-color: #f7931a; color: white; padding: 10px; font-size: 14px;')
        controls_layout.addWidget(self.execute_btn)

        layout.addLayout(controls_layout)

        # Statistics group
        stats_group = QGroupBox('📊 Statistics')
        stats_layout = QVBoxLayout()
        stats_group.setLayout(stats_layout)

        self.stats_labels = {}
        stats_items = [
            ('Total Transactions', 'total_tx'),
            ('Total Invested', 'total_invested'),
            ('Total BTC', 'total_btc'),
            ('Average Buy Price', 'avg_price'),
            ('Current Portfolio Value', 'portfolio_value'),
            ('ROI', 'roi')
        ]

        for label_text, key in stats_items:
            label_layout = QHBoxLayout()
            label = QLabel(f'{label_text}:')
            label.setFont(QFont('Arial', 11, QFont.Bold))
            value_label = QLabel('--')
            value_label.setFont(QFont('Arial', 11))
            value_label.setStyleSheet('color: #0ea5e9;')
            label_layout.addWidget(label)
            label_layout.addWidget(value_label)
            label_layout.addStretch()
            stats_layout.addLayout(label_layout)
            self.stats_labels[key] = value_label

        layout.addWidget(stats_group)

        # Chart
        chart_group = QGroupBox('📈 BTC Price History')
        chart_layout = QVBoxLayout()
        chart_group.setLayout(chart_layout)

        self.price_chart = pg.PlotWidget()
        self.price_chart.setBackground('w')
        self.price_chart.showGrid(x=True, y=True, alpha=0.3)
        self.price_chart.setLabel('left', 'BTC Price (USD)')
        self.price_chart.setLabel('bottom', 'Time')
        chart_layout.addWidget(self.price_chart)

        layout.addWidget(chart_group)

        return widget

    def create_transactions_tab(self):
        """Create transactions tab"""
        widget = QWidget()
        layout = QVBoxLayout()
        widget.setLayout(layout)

        # Transactions table
        self.transactions_table = QTableWidget()
        self.transactions_table.setColumnCount(8)
        self.transactions_table.setHorizontalHeaderLabels([
            'Timestamp', 'Pair', 'USD Amount', 'BTC Price',
            'BTC Amount', 'Fee', 'Status', 'Notes'
        ])
        layout.addWidget(self.transactions_table)

        # Refresh button
        refresh_btn = QPushButton('🔄 Refresh')
        refresh_btn.clicked.connect(self.load_transactions)
        layout.addWidget(refresh_btn)

        return widget

    def create_logs_tab(self):
        """Create logs tab"""
        widget = QWidget()
        layout = QVBoxLayout()
        widget.setLayout(layout)

        # Log text area
        self.log_text = QTextEdit()
        self.log_text.setReadOnly(True)
        self.log_text.setStyleSheet('background-color: #2d2d2d; color: #f8f8f2; font-family: monospace;')
        layout.addWidget(self.log_text)

        # Clear button
        clear_btn = QPushButton('🗑️ Clear Logs')
        clear_btn.clicked.connect(lambda: self.log_text.clear())
        layout.addWidget(clear_btn)

        return widget

    def create_settings_tab(self):
        """Create settings tab"""
        widget = QWidget()
        layout = QVBoxLayout()
        widget.setLayout(layout)

        # Settings form
        settings_group = QGroupBox('⚙️ Bot Configuration')
        settings_layout = QVBoxLayout()
        settings_group.setLayout(settings_layout)

        # Daily amount
        daily_layout = QHBoxLayout()
        daily_layout.addWidget(QLabel('Daily Amount (USD):'))
        self.daily_amount_input = QLineEdit('10')
        daily_layout.addWidget(self.daily_amount_input)
        settings_layout.addLayout(daily_layout)

        # Trading pair
        pair_layout = QHBoxLayout()
        pair_layout.addWidget(QLabel('Trading Pair:'))
        self.trading_pair_input = QLineEdit('BTC/USDT')
        pair_layout.addWidget(self.trading_pair_input)
        settings_layout.addLayout(pair_layout)

        # Interval
        interval_layout = QHBoxLayout()
        interval_layout.addWidget(QLabel('Interval (hours):'))
        self.interval_input = QLineEdit('24')
        interval_layout.addWidget(self.interval_input)
        settings_layout.addLayout(interval_layout)

        # Save button
        save_btn = QPushButton('💾 Save Settings')
        save_btn.clicked.connect(self.save_settings)
        settings_layout.addWidget(save_btn)

        layout.addWidget(settings_group)
        layout.addStretch()

        return widget

    def setup_timer(self):
        """Setup update timer"""
        self.update_timer = QTimer()
        self.update_timer.timeout.connect(self.update_dashboard)
        self.update_timer.start(5000)  # Update every 5 seconds

    def start_bot(self):
        """Start bot"""
        try:
            if self.bot is None:
                self.bot = DCABot()
                self.log('✅ Bot initialized successfully')

            self.is_running = True
            self.start_btn.setEnabled(False)
            self.stop_btn.setEnabled(True)
            self.statusBar().showMessage('Bot running...')
            self.log('🚀 Bot started')

        except Exception as e:
            self.log(f'❌ Failed to start bot: {e}')
            QMessageBox.critical(self, 'Error', f'Failed to start bot:\n{e}')

    def stop_bot(self):
        """Stop bot"""
        self.is_running = False
        self.start_btn.setEnabled(True)
        self.stop_btn.setEnabled(False)
        self.statusBar().showMessage('Bot stopped')
        self.log('🛑 Bot stopped')

    def execute_once(self):
        """Execute purchase once"""
        try:
            if self.bot is None:
                self.bot = DCABot()

            self.log('💸 Executing DCA purchase...')
            success = self.bot.run_once()

            if success:
                self.log('✅ Purchase completed successfully')
                self.update_dashboard()
                self.load_transactions()
            else:
                self.log('❌ Purchase failed')

        except Exception as e:
            self.log(f'❌ Error: {e}')
            QMessageBox.critical(self, 'Error', f'Purchase failed:\n{e}')

    def update_dashboard(self):
        """Update dashboard statistics"""
        if self.bot is None:
            return

        try:
            stats = self.bot.get_statistics()

            self.stats_labels['total_tx'].setText(str(stats['total_transactions']))
            self.stats_labels['total_invested'].setText(f"${stats['total_invested_usd']:.2f}")
            self.stats_labels['total_btc'].setText(f"{stats['total_btc']:.8f} BTC")
            self.stats_labels['avg_price'].setText(f"${stats['avg_buy_price']:.2f}")
            self.stats_labels['portfolio_value'].setText(f"${stats['current_portfolio_value']:.2f}")

            roi = stats['roi_percent']
            roi_color = '#28a745' if roi >= 0 else '#dc3545'
            self.stats_labels['roi'].setText(f"{roi:.2f}%")
            self.stats_labels['roi'].setStyleSheet(f'color: {roi_color};')

        except Exception as e:
            self.log(f'Error updating dashboard: {e}')

    def load_transactions(self):
        """Load transactions into table"""
        if self.bot is None:
            return

        try:
            cursor = self.bot.db_conn.cursor()
            cursor.execute('SELECT * FROM transactions ORDER BY timestamp DESC LIMIT 100')
            transactions = cursor.fetchall()

            self.transactions_table.setRowCount(len(transactions))

            for i, tx in enumerate(transactions):
                self.transactions_table.setItem(i, 0, QTableWidgetItem(tx[1]))  # timestamp
                self.transactions_table.setItem(i, 1, QTableWidgetItem(tx[2]))  # pair
                self.transactions_table.setItem(i, 2, QTableWidgetItem(f"${tx[3]:.2f}"))  # amount_usd
                self.transactions_table.setItem(i, 3, QTableWidgetItem(f"${tx[4]:.2f}"))  # btc_price
                self.transactions_table.setItem(i, 4, QTableWidgetItem(f"{tx[5]:.8f}"))  # btc_amount
                self.transactions_table.setItem(i, 5, QTableWidgetItem(f"${tx[6]:.4f}"))  # fee

                # Status with color
                status_item = QTableWidgetItem(tx[8])
                if tx[8] == 'completed':
                    status_item.setForeground(QColor('#28a745'))
                else:
                    status_item.setForeground(QColor('#dc3545'))
                self.transactions_table.setItem(i, 6, status_item)

                self.transactions_table.setItem(i, 7, QTableWidgetItem(tx[9] or ''))  # notes

            self.transactions_table.resizeColumnsToContents()

        except Exception as e:
            self.log(f'Error loading transactions: {e}')

    def save_settings(self):
        """Save settings"""
        # TODO: Save to .env file
        QMessageBox.information(self, 'Success', 'Settings saved!')
        self.log('💾 Settings saved')

    def log(self, message):
        """Add message to log"""
        timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        self.log_text.append(f'[{timestamp}] {message}')

    def closeEvent(self, event):
        """Handle window close"""
        if self.bot:
            self.bot.close()
        event.accept()


def main():
    app = QApplication(sys.argv)
    gui = DCABotGUI()
    gui.show()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()
