MobilApp/lib/services/project_service.dart

import 'package:get/get.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'package:supabase_flutter/supabase_flutter.dart';
import 'package:uuid/uuid.dart';
import '../models/project.dart';
import 'app_database.dart';

class ProjectService extends GetxService {
  static ProjectService get to => Get.find();

  final activeProject = Rxn<Project>();
  final projects = <Project>[].obs;

  int? get activeProjectId => activeProject.value?.id;

  @override
  Future<void> onInit() async {
    super.onInit();
    await _loadProjects();
    await _restoreActiveProject();
  }

  Future<void> _loadProjects() async {
    projects.value = await AppDatabase.instance.listProjects();
  }

  // Az utoljára aktív projektet tárolja a SharedPreferences
  Future<void> _restoreActiveProject() async {
    final prefs = await SharedPreferences.getInstance();
    final savedId = prefs.getInt('active_project_id');

    if (savedId != null) {
      final project = await AppDatabase.instance.getProject(savedId);
      if (project != null && project.status == ProjectStatus.active) {
        activeProject.value = project;
        return;
      }
    }
    // Fallback: az első aktív projekt
    if (projects.isNotEmpty) {
      await setActiveProject(projects.first);
    }
  }

  Future<void> setActiveProject(Project project) async {
    activeProject.value = project;
    final prefs = await SharedPreferences.getInstance();
    await prefs.setInt('active_project_id', project.id!);

    // Frissítjük az updated_at-et hogy a lista tetejére kerüljön
    await AppDatabase.instance.updateProject(project.copyWith());
    await _loadProjects();
  }

  Future<Project> createProject({
    required String name,
    String client = '',
    String description = '',
    ProjectCrs crs = ProjectCrs.eov,
    String color = '#185FA5',
  }) async {
    final now = DateTime.now();
    final project = Project(
      uuid: const Uuid().v4(),
      name: name,
      client: client,
      description: description,
      crs: crs,
      color: color,
      createdAt: now,
      updatedAt: now,
    );
    final id = await AppDatabase.instance.insertProject(project);
    final saved = project.copyWith();
    await _loadProjects();
    return await AppDatabase.instance.getProject(id) ?? saved;
  }

  /// Online projekt — szinkronizál Supabase-szel
  Future<Project> createOnlineProject({
    required String name,
    String client = '',
    ProjectCrs crs = ProjectCrs.eov,
    String color = '#185FA5',
  }) async {
    final project = Project(
      uuid: const Uuid().v4(),
      name: name,
      client: client,
      crs: crs,
      color: color,
      isLocalOnly: false, // ← szinkronizált
      createdAt: DateTime.now(),
      updatedAt: DateTime.now(),
    );

    // Lokálisan mentjük
    final id = await AppDatabase.instance.insertProject(project);

    // Supabase-be is
    await Supabase.instance.client
        .from('TerepiSeged_Projects')
        .insert(project.toMap());

    await _loadProjects();
    return await AppDatabase.instance.getProject(id) ?? project;
  }

  /// Lokális projekt — soha nem kerül Supabase-be
  Future<Project> createLocalProject({
    required String name,
    String client = '',
    ProjectCrs crs = ProjectCrs.eov,
    String color = '#185FA5',
  }) async {
    final project = Project(
      uuid: const Uuid().v4(),
      name: name,
      client: client,
      crs: crs,
      color: color,
      isLocalOnly: true, // ← csak lokális
      createdAt: DateTime.now(),
      updatedAt: DateTime.now(),
    );

    // Csak lokálisan
    final id = await AppDatabase.instance.insertProject(project);
    await _loadProjects();
    return await AppDatabase.instance.getProject(id) ?? project;
  }

  Future<void> reloadProjects() => _loadProjects();

  Future<Map<String, int>> getStats(int projectId) =>
      AppDatabase.instance.getProjectStats(projectId);

  Future<void> archiveProject(int id) async {
    await AppDatabase.instance.archiveProject(id);
    if (activeProject.value?.id == id) {
      activeProject.value = projects.isNotEmpty
          ? projects.firstWhereOrNull((p) => p.id != id)
          : null;
    }
  }

  Future<void> updateProject(Project project) async {
    await AppDatabase.instance.updateProject(project);
    await _loadProjects();

    if (activeProject.value?.id == project.id) {
      activeProject.value = project;
    }
  }
}