import 'dart:io';
import 'package:drift/drift.dart';
import 'package:flutter/foundation.dart';
import 'package:drift/wasm.dart' if (dart.library.io) 'wasm_stub.dart';
import 'package:path/path.dart' as p;
import 'package:path_provider/path_provider.dart';
import 'connection/connection.dart' as impl;



import 'database.drift.dart';

typedef Val<T> = Value<T>;

@DriftDatabase(
  tables: [
    DetailsDbTable,
   ... other table
  ],
  daos: [
    DetailsDbRepository,
   ... other Repository
  ],
  include: {'sql/schema.drift'},
)
class Database extends $Database {
  Database(super.executor);

  static Future<Database> create() async {
    Database? db;

    Future<Database> openDB() async {
      final connection = await impl.connect();
      db = Database._(connection);
      await db!.customSelect('SELECT 1').getSingle();

      return db!;
    }

    try {
      return await openDB();
    } catch (err, st) {
      debugPrint('DB open failed - recreating …\n$err\n$st');
      try {
        await db?.close();
      } catch (_) {}

      if (kIsWeb) {
        final probe = await WasmDatabase.probe(
          databaseName: Database.databaseFileName.split('.').first,
          sqlite3Uri: Uri.parse('/sqlite3.wasm'),
          driftWorkerUri: Uri.parse('/drift_worker.js'),
        );

        for (final existing in probe.existingDatabases) {
          if (existing.$2 == 'data') {
            await probe.deleteDatabase(existing);
            break;
          }
        }
      } else {
        final dir = await getApplicationDocumentsDirectory();
        final path = p.join(dir.path, Database.databaseFileName);
        try {
          await File(path).delete();
        } catch (err) {
          debugPrint('Could not delete $path: $err');
        }
      }

      return await openDB();
    }
  }

  Database._(DatabaseConnection super.connection);

  // DO NOT CHANGE DATABASE NAME
  static const databaseFileName = 'data.db';
  static const databasePortName = 'database_isolate_port';

  Database.forTesting(DatabaseConnection super.connection);

  Future<int> deleteEverything() async {
    int amountOfRowDeleted = 0;
    await customStatement('PRAGMA foreign_keys = OFF');
    try {
      await transaction(() async {
        for (final table in allTables) {
          amountOfRowDeleted += await delete(table).go();
        }
      });
    } finally {
      await customStatement('PRAGMA foreign_keys = ON');
    }
    return amountOfRowDeleted;
  }

  Future<int> deleteAllRowInTable(DbTableNameEnum tableName) async {
    final map = <DbTableNameEnum, TableInfo>{
      DbTableNameEnum.detailsDbTable: detailsDbTable,
      ... other enum
    };

    final tbl = map[tableName];
    if (tbl == null) return 0;

    await customStatement('PRAGMA foreign_keys = OFF');
    try {
      return await transaction(() => delete(tbl).go());
    } finally {
      await customStatement('PRAGMA foreign_keys = ON');
    }
  }

  @override
  int get schemaVersion => 7;

  @override
  MigrationStrategy get migration => MigrationStrategy(
    onCreate: (m) async {
      await m.createAll();
      await appSettingDbRepository.insertAppSetting();
    },
    onUpgrade: stepByStep(
      // version 2
      from1To2: (migrator, schema) async {
        await migrator.addColumn(
          settingDbTable,
          settingDbTable.dbEnableService,
        );
      },

      // version 3
      from2To3: (migrator, schema) async {
        await migrator.createTable(eventDbTable);
      },

      // version 4
      from3To4: (migrator, schema) async {
        await migrator.addColumn(
          settingDbTable,
          settingDbTable.dbBookings,
        );
      },

      // version 5
      from4To5: (migrator, schema) async {
        await migrator.addColumn(
          bookDbTable,
          bookDbTable.dbVersionId,
        );

        await migrator.addColumn(
          lineDbTable,
          lineDbTable.dbLineVersionId,
        );

        await migrator.addColumn(
          inspectDbTable,
          inspectDbTable.dbVersionId,
        );
      },

      // version 6
      from5To6: (migrator, schema) async {
        // Convert all DateTime columns to ISO-8601
        // for all DateTime columns in the database
        for (final table in allTables) {
          final dateTimeColumns = table.$columns.where(
            (c) => c.type == DriftSqlType.dateTime,
          );

          if (dateTimeColumns.isNotEmpty) {
            await migrator.alterTable(
              TableMigration(
                table,
                columnTransformer: {
                  for (final column in dateTimeColumns)
                    column: DateTimeExpressions.fromUnixEpoch(
                      column.dartCast<int>(),
                    ),
                },
              ),
            );
          }
        }
      },

      // version 7
      from6To7: (migrator, schema) async {
        await migrator.addColumn(
          appSettingDbTable,
          appSettingDbTable.dbServerAppVersionRecord,
        );
      },
    ),
    beforeOpen: (details) async {
      await customStatement('PRAGMA foreign_keys = ON');

      try {
        await impl.validateDatabaseSchema(this);
      } catch (e, s) {
        throw Exception(
          'Schema mismatch\n'
          'Error: $e\nStacktrace: $s',
        );
      }
    },
  );
}

export 'unsupported.dart'
    if (dart.library.js) 'web.dart'
    if (dart.library.ffi) 'native.dart';

import 'package:path/path.dart' as p;

Future<DriftIsolate> _createDriftIsolate() async {
  final directory = await getApplicationDocumentsDirectory();
  final dbPath = p.join(directory.path, Database.databaseFileName);
  final receivePort = ReceivePort();

  await Isolate.spawn(
    _startBackground,
    _IsolateStartRequest(receivePort.sendPort, dbPath),
  );

  return await receivePort.first as DriftIsolate;
}

void _startBackground(_IsolateStartRequest request) {
  final executor = NativeDatabase(File(request.dbPath));
  final driftIsolate = DriftIsolate.inCurrent(
    () => DatabaseConnection(executor),
  );

  request.sendPort.send(driftIsolate);
}

class _IsolateStartRequest {
  final SendPort sendPort;
  final String dbPath;

  _IsolateStartRequest(this.sendPort, this.dbPath);
}

Future<DatabaseConnection> connect() async {
  final driftIsolate = await _createDriftIsolate();
  final connection = await driftIsolate.connect();
  return connection;
}

Future<void> validateDatabaseSchema(GeneratedDatabase database) async {
  if (kDebugMode) {
    await VerifySelf(database).validateDatabaseSchema();
  }
}

import 'package:drift/drift.dart';

Never _unsupported() {
  throw UnsupportedError(
    'No suitable database implementation was found on this platform.',
  );
}

Future<DatabaseConnection> connect() async {
  _unsupported();
}

Future<void> validateDatabaseSchema(GeneratedDatabase database) async {
  _unsupported();
}

import 'dart:async';

import 'package:drift/drift.dart';
import 'package:drift/wasm.dart';
import 'package:flutter/foundation.dart';

/// Obtains a database connection for running drift on the web.
DatabaseConnection connect() {
  return DatabaseConnection.delayed(Future(() async {
    final db = await WasmDatabase.open(
      databaseName: 'data',
      sqlite3Uri: Uri.parse('/sqlite3.wasm'),
      driftWorkerUri: Uri.parse('/drift_worker.js'),
    );

    if (db.missingFeatures.isNotEmpty) {
      debugPrint('Using ${db.chosenImplementation} due to unsupported '
          'browser features: ${db.missingFeatures}');
    }

    return db.resolvedExecutor;
  }));
}

Future<void> validateDatabaseSchema(GeneratedDatabase database) async {
}