import time
from db_service import ThreadSafeDBOperations # Предполагая, что код сохранен в db_service.py

DB_FILE = 'quick_start.db'

# 1. Инициализация потокобезопасного соединения
db = ThreadSafeDBOperations(DB_FILE)
print("Соединение с БД установлено в фоновом потоке.")

# 2. Асинхронное создание таблицы
print("Отправка запроса на создание таблицы...")
future_create = db.create_table(
    'products',
    {'id': 'INTEGER PRIMARY KEY', 'name': 'TEXT', 'price': 'REAL'}
)
# Блокирующее ожидание результата (только для примера, в реальном коде используйте await)
future_create.result() 
print("Таблица создана.")

# 3. Асинхронная вставка данных
print("Отправка запроса на вставку данных...")
future_insert = db.insert('products', {'name': 'Laptop', 'price': 1500.00})
new_id = future_insert.result()
print(f"Вставлена новая запись с ID: {new_id}")

# 4. Асинхронная выборка данных
print("Отправка запроса на выборку...")
future_select = db.select('products', params={'ids': [new_id]})
result = future_select.result()
print("Результат выборки:", result)

# 5. Корректное закрытие соединения
db.close()
print("Соединение закрыто. Рабочий поток остановлен.")

from db_service import ThreadSafeDBOperations
from concurrent.futures import Future
import sqlite3

db = ThreadSafeDBOperations(':memory:')
db.create_table('test', {'id': 'INTEGER PRIMARY KEY', 'value': 'TEXT'}).result()

# Попытка вставить некорректные данные (например, отсутствие поля)
future_err = db.insert('test', {'wrong_field': 'data'})

try:
    # Ожидаем результат, который вызовет исключение
    future_err.result()
except Exception as e:
    # Исключение, возникшее в рабочем потоке, пробрасывается обратно через Future
    print(f"Перехвачена ошибка: {type(e).__name__}: {e}")
finally:
    db.close()

db = ThreadSafeDBOperations('test.db')
future_table = db.create_table(
    'accounts',
    {'id': 'INTEGER PRIMARY KEY', 'email': 'TEXT', 'is_active': 'INTEGER'}
)
future_table.result()

# Создание уникального индекса для email
future_index = db.create_index('accounts', 'email', unique=True)
future_index.result()

# Удаление индекса
future_drop = db.drop_index('accounts', 'email')
future_drop.result()

db.close()

db = ThreadSafeDBOperations('test.db')
db.create_table('items', {'id': 'INTEGER PRIMARY KEY', 'name': 'TEXT', 'status': 'TEXT'}).result()

# Вставка
insert_future = db.insert('items', {'name': 'Widget A', 'status': 'New'})
item_id = insert_future.result()

# Редактирование
edit_future = db.edit('items', item_id, {'status': 'Processed'})
rows_updated = edit_future.result()
print(f"Обновлено строк: {rows_updated}")

# Удаление
delete_future = db.delete('items', item_id)
rows_deleted = delete_future.result()
print(f"Удалено строк: {rows_deleted}")

db.close()

# Инициализация (пропущено для краткости, данные должны быть вставлены)
# ...

select_future = db.select(
    table_name='orders',
    joins=[
        {
            'type': 'INNER',
            'table': 'users',
            'on': 'orders.user_id = users.id'
        }
    ],
    params={
        # Фильтр: Только заказы, сделанные пользователем с ID 1
        'exact_match': {'orders': {'user_id': 1}},
        # Сортировка по дате заказа
        'sort': {'field': 'orders.order_date', 'order': 'DESC'},
        'limit': 10
    }
)

results = select_future.result()
# results: [{'id': 3, 'user_id': 1, 'product': 'Keyboard', ...}, ...]

# Расчет общей стоимости
total_price_future = db.aggregate('orders', 'SUM', 'price')
total = total_price_future.result()
print(f"Общая сумма заказов: {total}")

# Количество заказов в определенном диапазоне дат
count_future = db.aggregate(
    'orders', 
    'COUNT', 
    'id', 
    params={'date_range': ('2023-01-01', '2023-06-30')}
)
count = count_future.result()
print(f"Количество заказов за полугодие: {count}")

# Группировка пользователей по city_id
group_future = db.group_by(
    'users', 
    ['city_id'], 
    params={'sort': {'field': 'count', 'order': 'DESC'}}
)

groups = group_future.result()
# groups: [{'city_id': 2, 'count': 2}, {'city_id': 1, 'count': 2}, ...]

db = ThreadSafeDBOperations('test.db')
db.create_table('accounts', {'id': 'INTEGER PRIMARY KEY', 'balance': 'REAL'}).result()
db.insert('accounts', {'id': 1, 'balance': 1000.00}).result()
db.insert('accounts', {'id': 2, 'balance': 500.00}).result()

def transfer_money(from_id, to_id, amount):
    # Начало транзакции
    db.begin_transaction().result()
    
    try:
        # Списание
        db.edit('accounts', from_id, {'balance': 1000.00 - amount}).result()
        # Пополнение
        db.edit('accounts', to_id, {'balance': 500.00 + amount}).result()
        
        # Если все успешно
        db.commit_transaction().result()
        print("Транзакция успешно завершена.")
        return True
    except Exception as e:
        # Если произошла ошибка (например, Constraint Error), откатываем
        db.rollback_transaction().result()
        print(f"Ошибка транзакции: {e}. Откат.")
        return False

transfer_money(1, 2, 200.00)
db.close()