// ignore_for_file: unused_local_variable, unused_import
import 'package:drift/drift.dart';
import 'package:drift_dev/api/migrations.dart';
import 'package:spotube/models/database/database.dart';
import 'package:test/test.dart';
import 'generated/schema.dart';

import 'generated/schema_v1.dart' as v1;
import 'generated/schema_v2.dart' as v2;

void main() {
  driftRuntimeOptions.dontWarnAboutMultipleDatabases = true;
  late SchemaVerifier verifier;

  setUpAll(() {
    verifier = SchemaVerifier(GeneratedHelper());
  });

  group('simple database migrations', () {
    // These simple tests verify all possible schema updates with a simple (no
    // data) migration. This is a quick way to ensure that written database
    // migrations properly alter the schema.
    const versions = GeneratedHelper.versions;
    for (final (i, fromVersion) in versions.indexed) {
      group('from $fromVersion', () {
        for (final toVersion in versions.skip(i + 1)) {
          test('to $toVersion', () async {
            final schema = await verifier.schemaAt(fromVersion);
            final db = AppDatabase(schema.newConnection());
            await verifier.migrateAndValidate(db, toVersion);
            await db.close();
          });
        }
      });
    }
  });

  // Simple tests ensure the schema is transformed correctly, but some
  // migrations benefit from a test verifying that data is transformed correctly
  // too. This is particularly true for migrations that change existing columns
  // (e.g. altering their type or constraints). Migrations that only add tables
  // or columns typically don't need these advanced tests.
  // TODO: Check whether you have migrations that could benefit from these tests
  // and adapt this example to your database if necessary:
  test("migration from v1 to v2 does not corrupt data", () async {
    // Add data to insert into the old database, and the expected rows after the
    // migration.
    final oldAuthenticationTableData = <v1.AuthenticationTableData>[];
    final expectedNewAuthenticationTableData = <v2.AuthenticationTableData>[];

    final oldBlacklistTableData = <v1.BlacklistTableData>[];
    final expectedNewBlacklistTableData = <v2.BlacklistTableData>[];

    final oldPreferencesTableData = <v1.PreferencesTableData>[];
    final expectedNewPreferencesTableData = <v2.PreferencesTableData>[];

    final oldScrobblerTableData = <v1.ScrobblerTableData>[];
    final expectedNewScrobblerTableData = <v2.ScrobblerTableData>[];

    final oldSkipSegmentTableData = <v1.SkipSegmentTableData>[];
    final expectedNewSkipSegmentTableData = <v2.SkipSegmentTableData>[];

    final oldSourceMatchTableData = <v1.SourceMatchTableData>[];
    final expectedNewSourceMatchTableData = <v2.SourceMatchTableData>[];

    final oldAudioPlayerStateTableData = <v1.AudioPlayerStateTableData>[];
    final expectedNewAudioPlayerStateTableData =
        <v2.AudioPlayerStateTableData>[];

    final oldPlaylistTableData = <v1.PlaylistTableData>[];
    final expectedNewPlaylistTableData = <v2.PlaylistTableData>[];

    final oldPlaylistMediaTableData = <v1.PlaylistMediaTableData>[];
    final expectedNewPlaylistMediaTableData = <v2.PlaylistMediaTableData>[];

    final oldHistoryTableData = <v1.HistoryTableData>[];
    final expectedNewHistoryTableData = <v2.HistoryTableData>[];

    final oldLyricsTableData = <v1.LyricsTableData>[];
    final expectedNewLyricsTableData = <v2.LyricsTableData>[];

    await verifier.testWithDataIntegrity(
      oldVersion: 1,
      newVersion: 2,
      createOld: v1.DatabaseAtV1.new,
      createNew: v2.DatabaseAtV2.new,
      openTestedDatabase: (x) => AppDatabase(),
      createItems: (batch, oldDb) {
        batch.insertAll(oldDb.authenticationTable, oldAuthenticationTableData);
        batch.insertAll(oldDb.blacklistTable, oldBlacklistTableData);
        batch.insertAll(oldDb.preferencesTable, oldPreferencesTableData);
        batch.insertAll(oldDb.scrobblerTable, oldScrobblerTableData);
        batch.insertAll(oldDb.skipSegmentTable, oldSkipSegmentTableData);
        batch.insertAll(oldDb.sourceMatchTable, oldSourceMatchTableData);
        batch.insertAll(
            oldDb.audioPlayerStateTable, oldAudioPlayerStateTableData);
        batch.insertAll(oldDb.playlistTable, oldPlaylistTableData);
        batch.insertAll(oldDb.playlistMediaTable, oldPlaylistMediaTableData);
        batch.insertAll(oldDb.historyTable, oldHistoryTableData);
        batch.insertAll(oldDb.lyricsTable, oldLyricsTableData);
      },
      validateItems: (newDb) async {
        expect(expectedNewAuthenticationTableData,
            await newDb.select(newDb.authenticationTable).get());
        expect(expectedNewBlacklistTableData,
            await newDb.select(newDb.blacklistTable).get());
        expect(expectedNewPreferencesTableData,
            await newDb.select(newDb.preferencesTable).get());
        expect(expectedNewScrobblerTableData,
            await newDb.select(newDb.scrobblerTable).get());
        expect(expectedNewSkipSegmentTableData,
            await newDb.select(newDb.skipSegmentTable).get());
        expect(expectedNewSourceMatchTableData,
            await newDb.select(newDb.sourceMatchTable).get());
        expect(expectedNewAudioPlayerStateTableData,
            await newDb.select(newDb.audioPlayerStateTable).get());
        expect(expectedNewPlaylistTableData,
            await newDb.select(newDb.playlistTable).get());
        expect(expectedNewPlaylistMediaTableData,
            await newDb.select(newDb.playlistMediaTable).get());
        expect(expectedNewHistoryTableData,
            await newDb.select(newDb.historyTable).get());
        expect(expectedNewLyricsTableData,
            await newDb.select(newDb.lyricsTable).get());
      },
    );
  });
}