// lib/services/api/api_service.dart

import 'package:flutter/material.dart';

import 'package:Stocky/models/task_adapter.dart';
import 'package:Stocky/services/local/StorageService.dart';
import 'package:Stocky/utils/constants.dart';

import 'package:dio/dio.dart';
import 'package:get/get.dart';

class ApiService extends GetxService {
  static final ApiService _instance = ApiService._internal();

  ApiService._internal() {
    _setupDio();
  }

  final Dio _dio = Dio();

  String? get accessToken => Get.find<LocalStorageService>().getAccessToken();

  factory ApiService() => _instance;

  void _setupDio() {
    _dio.options.baseUrl = Constants.BASE_URL;
    _dio.options.connectTimeout = const Duration(seconds: 10);
    _dio.options.receiveTimeout = const Duration(seconds: 10);
    _dio.options.contentType = Headers.jsonContentType;
    _dio.interceptors.add(
      InterceptorsWrapper(
        onRequest: (options, handler) async {
          final token = accessToken;
          if (token != null) {
            options.headers['Authorization'] = 'Bearer $token';
          }
          return handler.next(options);
        },
        onResponse: (response, handler) => handler.next(response),
      ),
    );
  }

  Future registerByPhone(String phone) async {
    try {
      await _dio.post(
        '/register',
        data: {'application': 'warehouse', 'phone': phone},
      );
    } catch (e) {
      debugPrint('Регистрация по телефону: $e');
    }
  }

  Future<bool> loginByPhone(String phone, String digCode) async {
    try {
      final response = await _dio.post(
        '/login',
        data: {
          'phone': phone,
          'digCode': digCode,
          'application': 'warehouse',
        }, // ← убран пробел
      );

      if (response.statusCode == 200) {
        final data = response.data;
        final token = data['token'];
        final username = data['name'];
        Get.find<LocalStorageService>().saveAccessToken(token);
        Get.find<LocalStorageService>().putUsername(username);
        return true;
      }
    } catch (e) {
      debugPrint('Логин по телефону: $e');
    }
    return false;
  }

  Future<List<Task>> fetchTasks() async {
    try {
      final username = await Get.find<LocalStorageService>().getUsername();
      final response = await _dio.get('/warehouse/tasks/$username');
      if (response.statusCode == 200) {
        final List<dynamic> list = response.data;
        return list.map((item) => Task.fromMap(item)).toList();
      } else {
        debugPrint(
          'Некорректный статус при загрузке задач: ${response.statusCode}',
        );
      }
    } catch (e) {
      debugPrint('Ошибка загрузки задач: $e');
    }
    return [];
  }

  Future<Task?> upsertTask(Task task) async {
    if (task.isNew == true || task.id.isEmpty) {
      final saved = await saveTask(task);
      return saved;
    } else {
      final success = await updateTask(task);
      return success ? task : null;
    }
  }

  Future<Task?> saveTask(Task task) async {
    try {
      final response = await _dio.post('/warehouse/task', data: task.toMap());
      if (response.statusCode == 200) {
        return response.data;
      }
    } catch (e) {
      debugPrint('Ошибка сохранения задачи: $e');
    }
    return null;
  }

  Future<bool> updateTask(Task task) async {
    try {
      debugPrint('Обновление задачи: ${task.toMap()}');
      final response = await _dio.put('/warehouse/task', data: task.toMap());
      return response.statusCode == 201;
    } catch (e) {
      debugPrint('Ошибка обновления задачи: $e');
    }
    return false;
  }

  Future<bool> deleteTask(String taskId) async {
    try {
      final response = await _dio.delete('/warehouse/task/$taskId');
      return response.statusCode == 200;
    } catch (e) {
      debugPrint('Ошибка удаления задачи: $e');
    }
    return false;
  }

  void clearAuth() {
    Get.find<LocalStorageService>().clearAuth();
  }

  static Future<ApiService> init() async {
    final service = ApiService();
    Get.put(service, permanent: true);
    return service;
  }

  Future<bool> setFcmToken(String token) async {
    try {
      final response = await _dio.put(
        '/warehouse/user',
        data: {
          "number": await Get.find<LocalStorageService>().getNumber(),
          "notification": {
            "token": token.toString(),
            "enable": true,
            "type": "FCM",
          },
        },
      );
      return response.statusCode == 200;
    } catch (e) {
      debugPrint('Ошибка обновление токена: $e');
    }
    return false;
  }
}