marco.pms.mobileapp/lib/helpers/services/auth_service.dart

import 'dart:convert';
import 'package:http/http.dart' as http;
import 'package:get/get.dart';
import 'package:marco/helpers/services/storage/local_storage.dart';
import 'package:marco/controller/permission_controller.dart';
import 'package:logger/logger.dart';
final Logger logger = Logger();

class AuthService {
  static const String _baseUrl = "https://stageapi.marcoaiot.com/api";
  static const Map<String, String> _headers = {
    'Content-Type': 'application/json',
  };
  static bool isLoggedIn = false;
  static Future<Map<String, String>?> loginUser(
      Map<String, dynamic> data) async {
    try {
      final response = await http.post(
        Uri.parse("$_baseUrl/auth/login"),
        headers: _headers,
        body: jsonEncode(data),
      );

      final responseData = jsonDecode(response.body);
      if (response.statusCode == 200 && responseData['data'] != null) {
        isLoggedIn = true;

        final jwtToken = responseData['data']['token'];
        final refreshToken = responseData['data']['refreshToken'];

        // Log the tokens using the logger
        logger.i("JWT Token: $jwtToken");
        if (refreshToken != null) logger.i("Refresh Token: $refreshToken");

        await LocalStorage.setJwtToken(jwtToken);
        await LocalStorage.setLoggedInUser(true);

        if (refreshToken != null) {
          await LocalStorage.setRefreshToken(refreshToken);
        }

        Get.put(PermissionController());

        return null;
      } else if (response.statusCode == 401) {
        return {"password": "Invalid email or password"};
      } else {
        return {
          "error": responseData['message'] ?? "Unexpected error occurred"
        };
      }
    } catch (e) {
      logger.e("Login error: $e");
      return {"error": "Network error. Please check your connection."};
    }
  }

  /// Refreshes the JWT token using the refresh token.
  static Future<bool> refreshToken() async {
    final accessToken = await LocalStorage.getJwtToken();
    final refreshToken = await LocalStorage.getRefreshToken();

    if (accessToken == null ||
        refreshToken == null ||
        accessToken.isEmpty ||
        refreshToken.isEmpty) {
      logger.w("Missing token or refresh token for refresh.");
      return false;
    }

    final requestBody = {
      "token": accessToken,
      "refreshToken": refreshToken,
    };

    logger.i("Sending refresh token request with body: $requestBody");

    try {
      final response = await http.post(
        Uri.parse("$_baseUrl/auth/refresh-token"),
        headers: {
          'Content-Type': 'application/json',
        },
        body: jsonEncode(requestBody),
      );

      logger.i(
          "Refresh token API response (${response.statusCode}): ${response.body}");

      final data = jsonDecode(response.body);
      if (response.statusCode == 200 && data['success'] == true) {
        final newAccessToken = data['data']['token'];
        final newRefreshToken = data['data']['refreshToken'];

        if (newAccessToken == null || newRefreshToken == null) {
          logger.w("Invalid tokens received during refresh.");
          return false;
        }

        await LocalStorage.setJwtToken(newAccessToken);
        await LocalStorage.setRefreshToken(newRefreshToken);
        await LocalStorage.setLoggedInUser(true);

        logger.i("Token refreshed successfully.");
        return true;
      } else {
        logger.w("Refresh failed: ${data['message']}");
        return false;
      }
    } catch (e) {
      logger.e("Exception during token refresh: $e");
      return false;
    }
  }

// Forgot password API
  static Future<Map<String, String>?> forgotPassword(String email) async {
    final requestBody = {"email": email};

    logger.i("Sending forgot password request with email: $email");

    try {
      final response = await http.post(
        Uri.parse("$_baseUrl/auth/forgot-password"),
        headers: _headers,
        body: jsonEncode(requestBody),
      );

      logger.i(
          "Forgot password API response (${response.statusCode}): ${response.body}");

      final responseData = jsonDecode(response.body);

      if (response.statusCode == 200 && responseData['success'] == true) {
        logger.i("Forgot password request successful.");
        return null;
      } else {
        return {
          "error":
              responseData['message'] ?? "Failed to send password reset link."
        };
      }
    } catch (e) {
      logger.e("Exception during forgot password request: $e");
      return {"error": "Network error. Please check your connection."};
    }
  }

// Request demo API
  static Future<Map<String, String>?> requestDemo(
      Map<String, dynamic> demoData) async {
    try {
      final response = await http.post(
        Uri.parse("$_baseUrl/market/inquiry"),
        headers: _headers,
        body: jsonEncode(demoData),
      );

      final responseData = jsonDecode(response.body);

      if (response.statusCode == 200 && responseData['success'] == true) {
        logger.i("Request Demo submitted successfully.");
        return null;
      } else {
        return {
          "error": responseData['message'] ?? "Failed to submit demo request."
        };
      }
    } catch (e) {
      logger.e("Exception during request demo: $e");
      return {"error": "Network error. Please check your connection."};
    }
  }

  static Future<List<Map<String, dynamic>>?> getIndustries() async {
    try {
      final response = await http.get(
        Uri.parse("$_baseUrl/market/industries"),
        headers: _headers,
      );

      logger.i(
          "Get Industries API response (${response.statusCode}): ${response.body}");

      final responseData = jsonDecode(response.body);

      if (response.statusCode == 200 && responseData['success'] == true) {
        // Return the list of industries as List<Map<String, dynamic>>
        final List<dynamic> industriesData = responseData['data'];
        return industriesData.cast<Map<String, dynamic>>();
      } else {
        logger.w("Failed to fetch industries: ${responseData['message']}");
        return null;
      }
    } catch (e) {
      logger.e("Exception during getIndustries: $e");
      return null;
    }
  }
}