import 'dart:io';

import 'package:flutter_test/flutter_test.dart';
import 'package:fuel_tax_tracker/services/cloud/cloud_storage_provider.dart';
import 'package:fuel_tax_tracker/services/cloud_sync_service.dart';
import 'package:fuel_tax_tracker/services/database_service.dart';
import 'package:path/path.dart' as p;
import 'package:path_provider_platform_interface/path_provider_platform_interface.dart';
import 'package:plugin_platform_interface/plugin_platform_interface.dart';
import 'package:sqflite_common_ffi/sqflite_ffi.dart';

/// Confirms [CloudSyncService]'s orchestration (lock → check remote →
/// upload → release) works against *any* [CloudStorageProvider], using a
/// fake one — coverage for the provider-agnostic logic itself, independent
/// of which real backend (Google Drive, Dropbox, OneDrive) it's wired to.
void main() {
  late Directory tempDir;
  late DatabaseService databaseService;

  setUpAll(() {
    sqfliteFfiInit();
    databaseFactory = databaseFactoryFfi;
  });

  setUp(() async {
    tempDir = await Directory.systemTemp.createTemp('cloud_sync_service_test_');
    PathProviderPlatform.instance = _FakePathProviderPlatform(tempDir.path);
    databaseService = DatabaseService();
    await databaseService.init();
  });

  tearDown(() async {
    await databaseService.rawDb.close();
    await tempDir.delete(recursive: true);
  });

  test('syncNow acquires a lock, uploads the data file, and releases the lock', () async {
    final session = _FakeSession();
    final provider = _FakeProvider(session);
    final syncService = CloudSyncService(provider: provider, databaseService: databaseService);
    syncService.configure('app-folder-id');

    final result = await syncService.syncNow();

    expect(result.ranSync, isTrue);
    expect(session.createdLockNames, hasLength(1));
    expect(session.createdLockNames.first, startsWith('tester@example.com-'));
    expect(session.uploadedFileNames, contains(dataFileName));
    expect(session.deletedFileIds, ['lock-id'], reason: 'the lock must be released afterward');
  });

  test('syncNow uploads a pending receipt into Receipts/<vin>/<yyyy.mm>', () async {
    final session = _FakeSession();
    final provider = _FakeProvider(session);
    final syncService = CloudSyncService(provider: provider, databaseService: databaseService);
    syncService.configure('app-folder-id');

    final db = databaseService.rawDb;
    await db.insert('vehicles', {
      'id': 'vehicle-1',
      'vin': '1FMPU18L1TLB51349',
      'nickname': null,
      'updated_at': 0,
      'deleted_at': null,
      'dirty': 0,
    });
    final receiptFile = File(p.join(tempDir.path, 'receipt.jpg'))..writeAsBytesSync([1, 2, 3]);
    await db.insert('fuel_entries', {
      'id': 'entry-1',
      'vehicle_id': 'vehicle-1',
      // Mid-month/mid-year so DateTime.fromMillisecondsSinceEpoch's local
      // interpretation can't drift into a different month depending on the
      // machine's timezone (unlike epoch 0, which can land in Dec 1969).
      'date': DateTime(2026, 3, 15).millisecondsSinceEpoch,
      'gallons': 10.0,
      'price_per_gallon': 3.5,
      'total_cost': 35.0,
      'receipt_image_path': receiptFile.path,
      'receipt_drive_file_id': null,
      'updated_at': 0,
      'deleted_at': null,
      'dirty': 1,
    });

    final result = await syncService.syncNow(keepLocalReceiptCopies: true);

    expect(result.ranSync, isTrue);
    expect(session.uploadedFileFolders['entry-1.jpg'],
        'app-folder-id/$receiptsFolderName/1FMPU18L1TLB51349/2026.03');
  });

  test('selectAppFolder creates/finds the app folder under the picked parent', () async {
    final session = _FakeSession();
    final provider = _FakeProvider(session);
    final syncService = CloudSyncService(provider: provider, databaseService: databaseService);

    final folderId = await syncService.selectAppFolder('parent-id');

    expect(folderId, 'parent-id/$appFolderName');
    expect(session.findOrCreateFolderCalls, ['parent-id/$appFolderName']);
  });

  test('selectAppFolder uses the picked folder directly if it is already the app folder',
      () async {
    final session = _FakeSession();
    final provider = _FakeProvider(session);
    final syncService = CloudSyncService(provider: provider, databaseService: databaseService);

    final folderId =
        await syncService.selectAppFolder('parent-id/$appFolderName', currentFolderName: appFolderName);

    expect(folderId, 'parent-id/$appFolderName');
    expect(session.findOrCreateFolderCalls, isEmpty,
        reason: 'should not nest another app folder inside a folder already named that');
  });

  test('syncNow is a no-op when not configured with a folder yet', () async {
    final session = _FakeSession();
    final provider = _FakeProvider(session);
    final syncService = CloudSyncService(provider: provider, databaseService: databaseService);

    final result = await syncService.syncNow();

    expect(result.ranSync, isFalse);
    expect(session.createdLockNames, isEmpty);
  });
}

class _FakePathProviderPlatform extends PathProviderPlatform with MockPlatformInterfaceMixin {
  final String tempPath;
  _FakePathProviderPlatform(this.tempPath);

  @override
  Future<String?> getApplicationDocumentsPath() async => tempPath;

  @override
  Future<String?> getTemporaryPath() async => tempPath;
}

class _FakeSession implements CloudStorageSession {
  final List<String> createdLockNames = [];
  final List<String> deletedFileIds = [];
  final List<String> uploadedFileNames = [];
  final Map<String, String> uploadedFileFolders = {};
  final List<String> findOrCreateFolderCalls = [];
  CloudFileInfo? existingDataFile;

  @override
  bool get supportsSharedWithMe => false;

  @override
  Future<List<CloudFolder>> listFolders({String? parentId, bool sharedWithMe = false}) async => [];

  @override
  Future<String> findOrCreateFolder({required String parentId, required String name}) async {
    findOrCreateFolderCalls.add('$parentId/$name');
    return '$parentId/$name';
  }

  @override
  Future<CloudFileInfo?> findFile({required String folderId, required String name}) async {
    return name == dataFileName ? existingDataFile : null;
  }

  @override
  Future<List<int>> downloadFileBytes(String fileId) async => <int>[];

  @override
  Future<CloudFileInfo> uploadFile({
    required String folderId,
    required String name,
    String? existingFileId,
    required File localFile,
    required String contentType,
  }) async {
    uploadedFileNames.add(name);
    uploadedFileFolders[name] = folderId;
    return CloudFileInfo(id: 'uploaded-$name', versionTag: 'v1');
  }

  @override
  Future<void> deleteFile(String fileId) async => deletedFileIds.add(fileId);

  @override
  Future<String> createLockFile({required String folderId, required String name}) async {
    createdLockNames.add(name);
    return 'lock-id';
  }

  @override
  Future<List<CloudLockFile>> listLockFiles(String folderId) async => [];

  @override
  void close() {}
}

class _FakeProvider implements CloudStorageProvider {
  final _FakeSession session;
  _FakeProvider(this.session);

  @override
  CloudProviderId get id => CloudProviderId.googleDrive;

  @override
  String get displayName => 'Fake Provider';

  @override
  bool get isSignedIn => true;

  @override
  String? get accountLabel => 'tester@example.com';

  @override
  Future<bool> attemptSilentSignIn() async => true;

  @override
  Future<String> signIn() async => accountLabel!;

  @override
  Future<void> signOut() async {}

  @override
  CloudStorageSession beginSession() => session;
}