import 'dart:developer';

import 'package:flutter/foundation.dart';
import 'package:flutter/services.dart';
import 'package:path/path.dart';
import 'package:sqflite/sqflite.dart';

class DatabaseHelper {
  static final DatabaseHelper _instance = DatabaseHelper._internal();
  static Database? _database;

  factory DatabaseHelper() => _instance;

  DatabaseHelper._internal();

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

  Future<Database> _initDatabase() async {
    final path = await _getDatabasePath();
    log('Database path: $path');
    return await openDatabase(
      path,
      version: 1,
      onCreate: _onCreate,
      onOpen: _onOpen,
    ).catchError((error) {
      throw error;
    }).whenComplete(() => log('Database initialized'));
  }

  Future<void> _onCreate(Database db, int version) async {
    log('Creating tables...');

    await db.execute('''
            CREATE TABLE keychain (
            key TEXT,
            value TEXT,
            type TEXT,
            updateAt TEXT,
            resolvedAt TEXT,
            createdAt TEXT
          );
      ''');

    insert('email', '', 'user');
    insert('passwd', '', 'user');
    insert('devUUID', '', 'user');
    insert('userUUID', '', 'user');
    insert('userDevUUID', '', 'user');
    insert('status', '', 'user');

    insert('cliUUID', '', 'local');
    insert('ownerUUID', '', 'local');
    insert('cliName', '', 'local');

    insert('whatsapp', '', 'local');
    insert('provisional', '', 'local');
    insert('pets', '', 'local');
    insert('petAmountRegister', '', 'local');

    log('Tables created');
  }

  Future<void> _onOpen(Database db) async {
    log('Checking existing data...');
    await _checkExistingData(db);
  }

  Future<void> deleteDatabaseDB() async {
    final path = await _getDatabasePath();
    await deleteDatabase(path);
    log('Database deleted');
    _database = null;
  }

  Future<String> _getDatabasePath() async {
    final databasesPath = await getDatabasesPath();
    final path = join(databasesPath, 'database.db');
    log('Database path: $path');
    return path;
  }

  Future<void> _checkExistingData(Database db) async {
    try {
      final maps = await db.query('keychain');
      log('Existing data: $maps');
    } catch (error) {
      log('Error checking existing data: $error');
    }
  }

  Future<dynamic> get({String? key, String? field}) async {
    try {
      final db = await database;

      List<Map<String, dynamic>> queryResult;
      if (field != null && key != null) {
        queryResult = await db.query(
          'keychain',
          columns: [field],
          where: 'key = ?',
          whereArgs: [key],
        );
      } else if (field != null) {
        queryResult = await db.query(
          'keychain',
          columns: [field],
        );
      } else if (key != null) {
        field = 'value';

        queryResult = await db.query(
          'keychain',
          columns: [field],
          where: 'key = ?',
          whereArgs: [key],
        );
      } else {
        queryResult = await db.query('keychain');
      }

      log('Query result for key: $key, field: $field -> $queryResult');

      if (queryResult.isNotEmpty) {
        return queryResult.first[field];
      } else {
        return null;
      }
    } catch (error) {
      log('Error getting: $error');
      return null;
    }
  }

  Future<int> insert(String key, dynamic value, String? type) async {
    final db = await database;

    final Map<String, dynamic> data = {
      'key': key,
      'value': value.toString(),
      'type': type,
      'updateAt': DateTime.now().toIso8601String(),
      'resolvedAt': null,
      'createdAt': DateTime.now().toIso8601String(),
    };

    log('Inserting: $data');
    return await db.insert('keychain', data);
  }

  Future<int> update(String key, dynamic value, String? type) async {
    final db = await database;

    final Map<String, dynamic> data = {
      'key': key,
      if (value != null) 'value': value.toString(),
      if (type != null) 'type': type,
      'updateAt': DateTime.now().toIso8601String(),
      'resolvedAt': null,
      'createdAt': DateTime.now().toIso8601String(),
    };

    log('Updating: $data');
    return await db.update(
      'keychain',
      data,
      where: 'key = ?',
      whereArgs: [key],
    );
  }

  Future<int> delete(int id) async {
    final db = await database;
    log('Deleting with id: $id');
    return await db.delete('keychain', where: 'id = ?', whereArgs: [id]);
  }

  Future<int> purge() async {
    final db = await database;
    log('Deleting all');
    return await db.delete('keychain');
  }
}