nearle_pos/lib/data/remote/auth_api.dart

import 'dart:convert';

import 'package:http/http.dart' as http;

import '../../core/config/api_config.dart';
import '../../domain/entities/store_account.dart';

/// A back office that answered, but not with what was asked for.
///
/// [isNetworkFault] separates "the server said no" from "there was no server".
/// The first is final — a wrong password does not become right on a retry, and
/// must never fall through to a local account. The second is the shop's line
/// being down, which is the only case an offline path may consider.
class ApiException implements Exception {
  const ApiException(
    this.message, {
    this.statusCode,
    this.isNetworkFault = false,
  });

  final String message;
  final int? statusCode;
  final bool isNetworkFault;

  @override
  String toString() => message;
}

/// One person on the store's staff list, as the back office describes them.
///
/// ```json
/// { "user_id": 1148, "full_name": "Ragul Kannan",
///   "role": "Super admin", "pin": "1111", "status": "Active" }
/// ```
class ApiStaffMember {
  const ApiStaffMember({
    required this.userId,
    required this.fullName,
    required this.role,
    this.pin,
    this.status = 'Active',
  });

  final int userId;
  final String fullName;

  /// Free text from the back office: `Super admin`, `Admin`, `Cashier`,
  /// `Manager`. Compared case- and space-insensitively, never matched exactly.
  final String role;

  /// The till PIN. May be absent, in which case this person exists on the
  /// staff list but cannot be switched to at the counter.
  final String? pin;

  final String status;

  bool get isActive => status.trim().toLowerCase() == 'active';

  StaffRole get staffRole => ApiRoles.toStaffRole(role);

  bool get isAdmin => ApiRoles.isAdminRole(role);

  static ApiStaffMember fromJson(Map<String, Object?> json) => ApiStaffMember(
        userId: _asInt(json['user_id']) ?? 0,
        fullName: (json['full_name'] as String? ?? '').trim(),
        role: (json['role'] as String? ?? '').trim(),
        pin: _nonEmpty(json['pin'] as String?),
        status: (json['status'] as String? ?? 'Active').trim(),
      );
}

/// An outlet this account can sign into.
class ApiLocation {
  const ApiLocation({
    required this.locationId,
    required this.locationName,
    this.address = '',
    this.city = '',
    this.status = 'Active',
  });

  final int locationId;
  final String locationName;
  final String address;
  final String city;
  final String status;

  bool get isActive => status.trim().toLowerCase() == 'active';

  static ApiLocation fromJson(Map<String, Object?> json) => ApiLocation(
        locationId: _asInt(json['location_id']) ?? 0,
        locationName: (json['location_name'] as String? ?? '').trim(),
        address: (json['address'] as String? ?? '').trim(),
        city: (json['city'] as String? ?? '').trim(),
        status: (json['status'] as String? ?? 'Active').trim(),
      );
}

/// Everything the back office hands back on a successful sign-in.
///
/// This is the terminal's whole identity for the rest of the session: the
/// bearer token every other call carries, the location id the catalogue and
/// order endpoints are scoped to, and the tenant name shown beside the logo.
/// Nothing below it is guessed or held as a constant.
class LoginSession {
  const LoginSession({
    required this.token,
    required this.userId,
    required this.email,
    required this.roleId,
    required this.tenantId,
    required this.tenantName,
    required this.storeId,
    required this.locationId,
    required this.locationName,
    this.fullName = '',
    this.address = '',
    this.phone = '',
    this.expiresAt,
    this.locations = const [],
    this.staff = const [],
  });

  /// Bearer token. Sent as `authorization: Bearer …` on the catalogue pull and
  /// on every order push — see `SyncConfig.apiKey`, which this fills.
  final String token;

  final DateTime? expiresAt;

  final int userId;
  final String fullName;
  final String email;

  /// The back office's numeric role for this account. Used only when [staff]
  /// does not name this person — see [isAdmin].
  final int roleId;

  final int tenantId;
  final String tenantName;

  /// The back office sends this as a string; kept as one because it is used as
  /// a path and query value, never arithmetically.
  final String storeId;

  final int locationId;
  final String locationName;
  final String address;
  final String phone;

  final List<ApiLocation> locations;
  final List<ApiStaffMember> staff;

  /// What goes beside the logo. The tenant is the business, the location is
  /// the branch — a single-outlet shop usually sets both to the same thing.
  String get displayStoreName =>
      tenantName.isNotEmpty ? tenantName : locationName;

  /// Who signed in, for the profile row and for stamping bills.
  String get displayUserName {
    if (fullName.isNotEmpty) return fullName;
    final me = whoAmI;
    if (me != null && me.fullName.isNotEmpty) return me.fullName;
    final at = email.indexOf('@');
    return at > 0 ? email.substring(0, at) : email;
  }

  /// This account's own row in [staff], when the back office included one.
  ApiStaffMember? get whoAmI {
    for (final s in staff) {
      if (s.userId == userId) return s;
    }
    return null;
  }

  /// Which screen the terminal opens on.
  ///
  /// The staff list is the authority when it names this person, because it
  /// carries the role as text — `Super admin`, `Cashier` — which is what the
  /// back office actually manages. [roleId] is the fallback for the case in
  /// the sample response, where `staff` comes back empty.
  bool get isAdmin {
    final me = whoAmI;
    if (me != null && me.role.isNotEmpty) return me.isAdmin;
    return ApiRoles.adminRoleIds.contains(roleId);
  }

  /// The role to file this person under locally.
  StaffRole get staffRole {
    final me = whoAmI;
    if (me != null && me.role.isNotEmpty) return me.staffRole;
    return isAdmin ? StaffRole.admin : StaffRole.cashier;
  }

  bool get isExpired =>
      expiresAt != null && DateTime.now().isAfter(expiresAt!.toLocal());

  /// Reads `details`, not the envelope. [AuthApi.login] has already checked
  /// `status` and `code` by the time this runs.
  static LoginSession fromDetails(Map<String, Object?> d) {
    final locationId = _asInt(d['location_id']) ?? 0;

    return LoginSession(
      token: (d['token'] as String? ?? '').trim(),
      expiresAt: DateTime.tryParse(d['expires_at'] as String? ?? ''),
      userId: _asInt(d['user_id']) ?? 0,
      fullName: (d['full_name'] as String? ?? '').trim(),
      email: (d['email'] as String? ?? '').trim(),
      roleId: _asInt(d['role_id']) ?? 0,
      tenantId: _asInt(d['tenant_id']) ?? 0,
      tenantName: (d['tenant_name'] as String? ?? '').trim(),
      // Falls back to the location id: they are the same number in every
      // response seen so far, and a blank store id would scope the catalogue
      // pull to nothing.
      storeId: _nonEmpty(d['store_id']?.toString()) ?? '$locationId',
      locationId: locationId,
      locationName: (d['location_name'] as String? ?? '').trim(),
      address: (d['address'] as String? ?? '').trim(),
      phone: (d['phone'] as String? ?? '').trim(),
      locations: _list(d['locations'], ApiLocation.fromJson),
      staff: _list(d['staff'], ApiStaffMember.fromJson),
    );
  }
}

/// Maps the back office's role names onto what the terminal may open.
class ApiRoles {
  const ApiRoles._();

  /// Numeric roles that open the full shell, for responses whose `staff` array
  /// is empty. `1` is Super admin.
  ///
  /// Add to this rather than to the string rules if the back office introduces
  /// another privileged role id.
  static const Set<int> adminRoleIds = {1, 2};

  /// Case, spacing and punctuation are all ignored: `Super admin`,
  /// `super_admin` and `SUPERADMIN` are one role, and the back office is free
  /// to change how it writes them.
  static String _normalise(String role) =>
      role.toLowerCase().replaceAll(RegExp(r'[^a-z]'), '');

  /// True for anything that should land on the admin shell rather than the
  /// billing screen alone.
  static bool isAdminRole(String role) {
    final r = _normalise(role);
    if (r.isEmpty) return false;
    // `superadmin` contains `admin`, so one check covers both.
    return r.contains('admin') || r == 'owner';
  }

  static StaffRole toStaffRole(String role) {
    final r = _normalise(role);
    if (r.contains('admin') || r == 'owner') return StaffRole.admin;
    if (r.contains('manager') || r.contains('supervisor')) {
      return StaffRole.manager;
    }
    return StaffRole.cashier;
  }
}

/// Signs a terminal in against the back office.
///
/// ```
/// POST {base}/login
/// { "authname": "rmart@gmail.com", "password": "…",
///   "device_id": "a5f3c8b9-…", "configid": 1 }
/// ```
///
/// `device_id` is this till's own minted identity — not a fresh uuid per
/// attempt — so the back office can recognise a terminal across restarts and
/// refuse one it has not registered.
class AuthApi {
  AuthApi({http.Client? client, this.baseUrl = ApiConfig.baseUrl})
      : _client = client ?? http.Client();

  final http.Client _client;
  final String baseUrl;

  Future<LoginSession> login({
    required String authname,
    required String password,
    required String deviceId,
    int configId = ApiConfig.configId,
  }) async {
    final uri = Uri.parse('$baseUrl${ApiConfig.loginPath}');

    http.Response response;
    try {
      response = await _client
          .post(
            uri,
            headers: const {
              'content-type': 'application/json',
              'accept': 'application/json',
            },
            body: jsonEncode({
              'authname': authname.trim(),
              'password': password,
              'device_id': deviceId,
              'configid': configId,
            }),
          )
          .timeout(ApiConfig.timeout);
    } on Object catch (e) {
      throw ApiException(
        'Could not reach the back office. Check this terminal’s internet '
        'connection and try again. ($e)',
        isNetworkFault: true,
      );
    }

    Map<String, Object?> body;
    try {
      body = jsonDecode(response.body) as Map<String, Object?>;
    } on Object {
      throw ApiException(
        'The back office answered with something this terminal could not '
        'read (${response.statusCode}).',
        statusCode: response.statusCode,
      );
    }

    final ok = body['status'] == true && _asInt(body['code']) == 200;
    final details = body['details'];

    if (!ok || details is! Map<String, Object?>) {
      // The server's own wording is better than anything invented here: it
      // knows whether the account is wrong, locked, or on a device the shop
      // has not registered.
      throw ApiException(
        (body['message'] as String?)?.trim().isNotEmpty ?? false
            ? body['message']! as String
            : 'Sign-in was refused (${response.statusCode}).',
        statusCode: response.statusCode,
      );
    }

    final session = LoginSession.fromDetails(details);

    if (session.token.isEmpty) {
      throw const ApiException(
        'The back office signed this account in but returned no token, so '
        'nothing else could be fetched. Contact support.',
      );
    }

    if (session.locationId == 0) {
      throw const ApiException(
        'The back office returned no location for this account. A terminal '
        'has to belong to an outlet before it can pull products.',
      );
    }

    return session;
  }

  void dispose() => _client.close();
}

// ------------------------------------------------------------------ Helpers
/// The back office is inconsistent about numbers — `store_id` arrives quoted,
/// `location_id` bare — so both shapes are accepted everywhere.
int? _asInt(Object? value) => switch (value) {
      int v => v,
      num v => v.toInt(),
      String v => int.tryParse(v.trim()),
      _ => null,
    };

String? _nonEmpty(String? value) {
  final t = value?.trim();
  return (t == null || t.isEmpty) ? null : t;
}

List<T> _list<T>(Object? raw, T Function(Map<String, Object?>) decode) {
  if (raw is! List) return const [];
  return raw.whereType<Map<String, Object?>>().map(decode).toList();
}