import 'dart:async';
import 'package:path/path.dart';
import 'package:sqflite/sqflite.dart';

class DatabaseHelper {
  static final DatabaseHelper _instance = DatabaseHelper._internal();
  factory DatabaseHelper() => _instance;

  static Database? _database;

  DatabaseHelper._internal();

  Future<Database> get database async {
    if (_database != null) return _database!;
    _database = await _initDatabase();
    return _database!;
  }

  Future<Database> _initDatabase() async {
    final dbPath = await getDatabasesPath();
    final path = join(dbPath, 'sync_data.db');

    return await openDatabase(
      path,
      version: 2,
      onCreate: (db, version) async {
        await db.execute('''
          CREATE TABLE sync_data (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            folder TEXT NOT NULL,
            enabled INTEGER NOT NULL,
            interval INTEGER NOT NULL,
            last_synced TEXT,
            file_path TEXT,
            sync_status INTEGER NOT NULL DEFAULT 0
          )
        ''');
        await db.execute('''
          CREATE TABLE sync_events (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            event_type TEXT NOT NULL,
            folder TEXT,
            s3_key TEXT,
            local_path TEXT,
            size INTEGER,
            hash TEXT,
            status TEXT,
            message TEXT,
            ts TEXT NOT NULL
          )
        ''');
      },
      onUpgrade: (db, oldVersion, newVersion) async {
        if (oldVersion < 2) {
          await db.execute('''
            CREATE TABLE IF NOT EXISTS sync_events (
              id INTEGER PRIMARY KEY AUTOINCREMENT,
              event_type TEXT NOT NULL,
              folder TEXT,
              s3_key TEXT,
              local_path TEXT,
              size INTEGER,
              hash TEXT,
              status TEXT,
              message TEXT,
              ts TEXT NOT NULL
            )
          ''');
        }
      },
    );
  }

  Future<int> insertSyncData(Map<String, dynamic> data) async {
    final db = await database;
    return await db.insert('sync_data', data);
  }

  Future<List<Map<String, dynamic>>> getUnsyncedOrUpdatedData() async {
    final db = await database;
    return await db.query('sync_data', where: 'sync_status IN (0, 2)');
  }

  Future<int> updateSyncStatus(int id, int status) async {
    final db = await database;
    return await db.update(
      'sync_data',
      {'sync_status': status},
      where: 'id = ?',
      whereArgs: [id],
    );
  }

  Future<int> insertEvent({
    required String eventType,
    String? folder,
    String? s3Key,
    String? localPath,
    int? size,
    String? hash,
    String? status,
    String? message,
  }) async {
    final db = await database;
    return await db.insert('sync_events', {
      'event_type': eventType,
      'folder': folder,
      's3_key': s3Key,
      'local_path': localPath,
      'size': size,
      'hash': hash,
      'status': status,
      'message': message,
      'ts': DateTime.now().toIso8601String(),
    });
  }

  Future<List<Map<String, dynamic>>> recentEvents({int limit = 100}) async {
    final db = await database;
    return await db.query('sync_events', orderBy: 'id DESC', limit: limit);
  }
}