from datetime import datetime
from typing import Optional
from fastapi import APIRouter, HTTPException, BackgroundTasks, Query
from app.models.replication import ReplicationMetadata
from app.repository.replication_metadata_repo import replication_metadata_repo
from app.services.scheduler import scheduler
from app.services.migrator import migrator
from app.services.replication_state import replication_state
from app.core.logging import migration_logger
from app.core.config import settings
from app.utils.email_sender import email_sender
from app.taskiq.broker import refresh_schedules

router = APIRouter(prefix="/api/v1")


@router.post("/migrate/start")
async def start_migration(background_tasks: BackgroundTasks, full_reload: bool = False):
    """Запуск миграции"""
    if migrator.is_running:
        raise HTTPException(status_code=400, detail="Миграция уже выполняется")
    
    background_tasks.add_task(run_migration_task, full_reload)
    return {"message": "Миграция запущена", "full_reload": full_reload}


@router.post("/migrate/stop")
async def stop_migration():
    migrator.stop_migration()
    return {"message": "Миграция останавливается"}


@router.get("/migrate/status")
async def get_status():
    return migrator.get_status()

@router.get("/replication/last")
async def get_last_replication():
    """Получить информацию о последней репликации (максимальное время по всем таблицам)"""
    return replication_state.get_last_replication_info()


@router.get("/replication/tables")
async def get_tables_status():
    """Получить статус всех таблиц (из replication_metadata)"""
    stats = replication_state.get_all_stats()
    
    # Форматируем для API
    result = []
    for table in stats['tables']:
        result.append({
            "table": table['name'],
            "last_id": table['last_id'],
            "rows_count": table['rows'],
            "last_sync": table['last_sync'].isoformat() if table['last_sync'] else None,
            "active": table['active']
        })
    
    return {
        "total_rows": stats['total_rows'],
        "tables_count": stats['tables_count'],
        "active_tables": stats['active_tables'],
        "tables": result
    }


@router.get("/replication/tables/{table_name}")
async def get_table_status(table_name: str):
    """Получить статус конкретной таблицы"""
    from app.repository.replication_metadata_repo import replication_metadata_repo
    
    metadata = replication_metadata_repo.get_table_metadata(table_name)
    if not metadata:
        raise HTTPException(status_code=404, detail=f"Таблица {table_name} не найдена")
    
    return {
        "table": metadata.table_name,
        "last_id": metadata.last_id,
        "last_sync_time": metadata.last_sync_time.isoformat() if metadata.last_sync_time else None,
        "total_rows": metadata.total_rows,
        "is_active": metadata.is_active,
        "created_at": metadata.created_at.isoformat() if metadata.created_at else None,
        "updated_at": metadata.updated_at.isoformat() if metadata.updated_at else None,
        "last_error": metadata.last_error
    }


@router.post("/replication/tables/{table_name}/reset")
async def reset_table(table_name: str):
    """Сбросить состояние таблицы (обнулить last_id и last_sync_time)"""
    from app.repository.replication_metadata_repo import replication_metadata_repo
    
    session = replication_metadata_repo.get_session()
    try:
        metadata = session.query(ReplicationMetadata).filter_by(table_name=table_name).first()
        if metadata:
            metadata.last_id = 0
            metadata.last_sync_time = datetime(1900, 1, 1)
            metadata.total_rows = 0
            metadata.last_error = None
            metadata.updated_at = datetime.now()
            session.commit()
            
            migration_logger.info(f"Сброшено состояние таблицы {table_name}")
            return {"message": f"Состояние таблицы {table_name} сброшено"}
        else:
            raise HTTPException(status_code=404, detail=f"Таблица {table_name} не найдена")
    finally:
        session.close()


@router.get("/replication/logs")
async def get_replication_logs(
    table_name: Optional[str] = None,
    limit: int = Query(100, ge=1, le=1000),
    status: Optional[str] = None
):
    """Получить логи репликации"""
    from app.repository.replication_metadata_repo import replication_metadata_repo
    from app.models.replication import ReplicationLog
    
    session = replication_metadata_repo.get_session()
    try:
        query = session.query(ReplicationLog).order_by(ReplicationLog.created_at.desc())
        
        if table_name:
            query = query.filter(ReplicationLog.table_name == table_name)
        
        if status:
            query = query.filter(ReplicationLog.status == status.upper())
        
        logs = query.limit(limit).all()
        
        return [
            {
                "id": log.id,
                "table_name": log.table_name,
                "operation": log.operation,
                "records_count": log.records_count,
                "status": log.status,
                "error_message": log.error_message,
                "created_at": log.created_at.isoformat()
            }
            for log in logs
        ]
    finally:
        session.close()

@router.post("/test-email")
async def test_email():
    """Тест отправки email"""
    success = email_sender.send_email(
        subject="Тестовое письмо",
        body=f"Это тестовое письмо от Migration Service\n\nВремя: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
    )
    if success:
        return {"message": "Тестовое письмо отправлено"}
    else:
        raise HTTPException(status_code=500, detail="Ошибка отправки письма")


def run_migration_task(full_reload: bool):
    try:
        migrator.run_migration(full_reload=full_reload)
    except Exception as e:
        migration_logger.error("Ошибка в фоновой задаче", e)


# ==================== РАСПИСАНИЯ ====================

@router.get("/schedules")
async def get_schedules():
    """Получить все расписания миграций"""
    schedules = replication_metadata_repo.get_all_schedules()
    return [s.to_dict() for s in schedules]


@router.get("/schedules/next-runs")
async def get_next_runs(limit: int = 10):
    """Получить следующие запуски"""
    from datetime import timedelta
    
    now = datetime.now()
    runs = []
    
    # Получаем все расписания
    schedules = replication_metadata_repo.get_all_schedules()
    
    for minute_offset in range(60 * 24 * 7):  # Проверяем на неделю вперед
        check_time = now + timedelta(minutes=minute_offset)
        check_time_obj = check_time.time()
        check_weekday = check_time.weekday()
        
        for schedule in schedules:
            if not schedule.enabled:
                continue
            
            # Проверяем совпадение времени и дня
            time_diff = abs(
                (schedule.schedule_time.hour * 60 + schedule.schedule_time.minute) -
                (check_time_obj.hour * 60 + check_time_obj.minute)
            )
            
            if time_diff <= 1 and check_weekday in schedule.days_list:
                # Получаем статистику таблицы
                metadata = replication_metadata_repo.get_table_metadata(schedule.table_name)
                
                runs.append({
                    'table': schedule.table_name,
                    'time': check_time.strftime('%Y-%m-%d %H:%M'),
                    'day': check_time.strftime('%A'),
                    'days_schedule': schedule.days_display,
                    'full_reload': schedule.full_reload,
                    'rows_count': metadata.total_rows if metadata else 0,
                    'last_sync': metadata.last_sync_time.isoformat() if metadata and metadata.last_sync_time else None
                })
                
                if len(runs) >= limit:
                    break
        
        if len(runs) >= limit:
            break
    
    return runs[:limit]


@router.post("/schedules/run-now")
async def run_scheduled_now(background_tasks: BackgroundTasks):
    """Принудительно запустить все запланированные на текущее время миграции"""
    due = scheduler.get_due_tables()
    if not due:
        return {'message': 'Нет таблиц для миграции в текущее время и день'}
    
    for schedule in due:
        background_tasks.add_task(
            run_scheduled_migration,
            schedule.table_name,
            schedule.full_reload
        )
    
    return {
        'message': f'Запущено {len(due)} миграций',
        'tables': [
            {
                'name': s.table_name, 
                'time': s.schedule_time.strftime("%H:%M"), 
                'days': s.days_display,
                'full_reload': s.full_reload
            } 
            for s in due
        ]
    }


@router.post("/schedules/{table_name}")
async def set_schedule(
    table_name: str,
    schedule_time: str = Query("00:00", description="Время в формате HH:MM"),
    days: Optional[str] = Query(None, description="Дни недели через запятую: пн,вт,ср,чт,пт,сб,вс"),
    full_reload: bool = Query(False, description="Полная перезагрузка"),
    enabled: bool = Query(True, description="Включено"),
    name: Optional[str] = Query(None, description="Название расписания"),
    description: Optional[str] = Query(None, description="Описание")
):
    """Добавить новое расписание для таблицы"""
    try:
        if table_name not in settings.TABLES_TO_COPY:
            raise HTTPException(status_code=404, detail=f"Таблица {table_name} не найдена")
        
        days_list = None
        if days:
            days_list = [d.strip() for d in days.split(',')]
        
        from app.repository.replication_metadata_repo import replication_metadata_repo
        
        schedule = replication_metadata_repo.add_schedule(
            table_name=table_name,
            schedule_time=schedule_time,
            days=days_list,
            full_reload=full_reload,
            enabled=enabled,
            name=name,
            description=description
        )
        
        if schedule:
            await refresh_schedules()
            return {
                "message": f"Расписание добавлено для {table_name} в {schedule_time}",
                "schedule": schedule
            }
        else:
            raise HTTPException(status_code=500, detail="Ошибка добавления расписания")
            
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))

@router.get("/schedules/{table_name}")
async def get_table_schedule(table_name: str):
    """Получить расписание для конкретной таблицы"""
    schedule = replication_metadata_repo.get_schedule(table_name)
    if not schedule:
        raise HTTPException(status_code=404, detail="Расписание не найдено")
    
    # Получаем статистику таблицы
    metadata = replication_metadata_repo.get_table_metadata(table_name)
    
    result = schedule.to_dict()
    if metadata:
        result['table_stats'] = {
            'rows_count': metadata.total_rows,
            'last_sync': metadata.last_sync_time.isoformat() if metadata.last_sync_time else None,
            'last_id': metadata.last_id
        }
    
    return result

@router.put("/schedules/{schedule_id}")
async def update_schedule(
    schedule_id: int,
    schedule_time: Optional[str] = Query(None, description="Время в формате HH:MM"),
    days: Optional[str] = Query(None, description="Дни недели через запятую"),
    full_reload: Optional[bool] = Query(None, description="Полная перезагрузка"),
    enabled: Optional[bool] = Query(None, description="Включено"),
    name: Optional[str] = Query(None, description="Название"),
    description: Optional[str] = Query(None, description="Описание")
):
    """Обновить существующее расписание по ID"""
    from app.repository.replication_metadata_repo import replication_metadata_repo
    
    update_kwargs = {}
    if schedule_time:
        update_kwargs['schedule_time'] = schedule_time
    if days:
        update_kwargs['days'] = [d.strip() for d in days.split(',')]
    if full_reload is not None:
        update_kwargs['full_reload'] = full_reload
    if enabled is not None:
        update_kwargs['enabled'] = enabled
    if name:
        update_kwargs['name'] = name
    if description:
        update_kwargs['description'] = description
    
    success = replication_metadata_repo.update_schedule(schedule_id, **update_kwargs)
    
    if success:
        await refresh_schedules()
        return {"message": f"Расписание {schedule_id} обновлено"}
    else:
        raise HTTPException(status_code=404, detail=f"Расписание {schedule_id} не найдено")

@router.post("/schedules/{table_name}/disable")
async def disable_schedule(table_name: str):
    """Отключить расписание"""
    success = replication_metadata_repo.disable_schedule(table_name)
    if success:
        await refresh_schedules()
        return {'message': f'Расписание для {table_name} отключено'}
    else:
        raise HTTPException(status_code=404, detail=f"Расписание для {table_name} не найдено")


@router.post("/schedules/{table_name}/enable")
async def enable_schedule(table_name: str):
    """Включить расписание"""
    success = replication_metadata_repo.enable_schedule(table_name)
    if success:
        await refresh_schedules()
        return {'message': f'Расписание для {table_name} включено'}
    else:
        raise HTTPException(status_code=404, detail=f"Расписание для {table_name} не найдено")

# ==================== Фоновые задачи ====================

def run_migration_task(full_reload: bool):
    """Фоновая задача для миграции всех таблиц"""
    try:
        migrator.run_migration(full_reload=full_reload)
    except Exception as e:
        migration_logger.error(f"Ошибка в фоновой задаче: {e}")
        migration_logger.exception(e)


def run_scheduled_migration(table_name: str, full_reload: bool):
    """Фоновая задача для запланированной миграции одной таблицы"""
    try:
        migration_logger.info(f"Запуск запланированной миграции для {table_name}")
        
        migrator.run_migration(
            tables=[table_name],
            full_reload=full_reload,
            send_email=True
        )
        
        # Обновляем время последнего запуска в расписании
        replication_metadata_repo.update_schedule_last_run(table_name)
        
        # Логируем успешный запуск
        replication_metadata_repo.log_operation(
            table_name=table_name,
            operation='SCHEDULED',
            records_count=0,
            status='SUCCESS'
        )
        
        migration_logger.info(f"Запланированная миграция для {table_name} завершена")
        
    except Exception as e:
        error_msg = f"Ошибка в запланированной миграции для {table_name}: {e}"
        migration_logger.error(error_msg)
        migration_logger.exception(e)
        
        # Логируем ошибку
        replication_metadata_repo.log_operation(
            table_name=table_name,
            operation='SCHEDULED',
            records_count=0,
            status='ERROR',
            error_message=str(e)[:500]
        )