import 'dart:convert';
import 'dart:developer' as dev;
import 'dart:math';
import 'package:wanisclient/config/api_response.dart';
import 'package:http/http.dart' as http;
import 'package:xml/xml.dart' as xml;
import 'package:shared_preferences/shared_preferences.dart';

import '../config/AppSnackbar.dart';
import '../config/constants/app_constant.dart';
import '../models/userAddress_model.dart';
import '../providers/utils_singleton.dart';

class UserAddressService {
  Future<APIResponse<List<UserAddress>>> getAllAddresses() async {
    try {
      final response = await http.get(
        Uri.https(baseUrl, '/api/v1/user_address/get_all'),
        headers: {
          'Content-Type': 'application/json',
          'Accept': 'application/json',
          'Authorization': 'Bearer ${utils.token}',
        },
      );

      if (response.statusCode == 200 || response.statusCode == 201) {
        final jsonData = json.decode(response.body);

        final List<dynamic> results = jsonData['result'] ?? [];

        final List<UserAddress> list = results
            .map((e) => UserAddress.fromJson(e as Map<String, dynamic>))
            .toList();
        return APIResponse<List<UserAddress>>(
          statusCode: response.statusCode,
          data: list,
        );
      } else {
        return APIResponse<List<UserAddress>>(
          statusCode: response.statusCode,
          errorMessage: 'Failed to load history (HTTP ${response.statusCode})',
        );
      }
    } catch (e, st) {
      dev.log('getAllAddress() error', error: e, stackTrace: st);
      return APIResponse<List<UserAddress>>(
        errorMessage: e.toString(),
      );
    }
  }

  Future<APIResponse<List<UserAddress>>> getHistorie() async {
    try {
      final response = await http.get(
        Uri.https(baseUrl, '/api/v1/user_address/get_all_my_address_histroy'),
        headers: {
          'Content-Type': 'application/json',
          'Accept': 'application/json',
          'Authorization': 'Bearer ${utils.token}',
        },
      );

      if (response.statusCode == 200 || response.statusCode == 201) {
        final jsonData =
            json.decode(response.body); // Parse JSON instead of XML
        final List<UserAddress> list =
            (jsonData as List) // cast to List<dynamic>
                .map((e) => UserAddress.fromJson(
                    e as Map<String, dynamic>)) // map each item
                .toList();
        return APIResponse<List<UserAddress>>(
          statusCode: response.statusCode,
          data: list,
        );
      } else {
        return APIResponse<List<UserAddress>>(
          statusCode: response.statusCode,
          errorMessage: 'Failed to load history (HTTP ${response.statusCode})',
        );
      }
    } catch (e, st) {
      dev.log('getHistorie() error', error: e, stackTrace: st);
      return APIResponse<List<UserAddress>>(
        errorMessage: e.toString(),
      );
    }
  }

  Future<APIResponse<MyAddressesResponse>> getHistorieWorkHome() async {
    try {
      final response = await http.get(
        Uri.https(baseUrl, '/api/v1/user_address/my_address'),
        headers: {
          'Content-Type': 'application/json',
          'Accept': 'application/json',
          'Authorization': 'Bearer ${utils.token}',
        },
      );

      if (response.statusCode == 200 || response.statusCode == 201) {
        print("---------------- addresses ------------- ${response.body}");
        final jsonData = json.decode(response.body);
        final MyAddressesResponse list = MyAddressesResponse.fromJson(jsonData);

        return APIResponse<MyAddressesResponse>(
          statusCode: response.statusCode,
          data: list,
        );
      } else {
        return APIResponse<MyAddressesResponse>(
          statusCode: response.statusCode,
          errorMessage: 'Failed to load history (HTTP ${response.statusCode})',
        );
      }
    } catch (e, st) {
      dev.log('getHistorie() error', error: e, stackTrace: st);
      return APIResponse<MyAddressesResponse>(
        errorMessage: e.toString(),
      );
    }
  }

  Future<void> addAddress(List<UserAddress> address) async {
    print("address++++ ${address}");
    final response = await http.post(
      Uri.https(baseUrl, '/api/v1/user_address/add'),
      headers: {
        'Content-Type': 'application/json',
        'Accept': 'application/json',
        'Authorization': 'Bearer ${utils.token}',
      },
      body: json.encode(address.map((a) => a.toJson()).toList()),
    );
    if (response.statusCode == 200) {
      AppSnackbar.showSuccess(
        "Success",
        "Address added successfully",
      );
      print("response++++ ${response.body}");
    } else if (response.statusCode != 200) {
      AppSnackbar.showError(
        "Error",
        "Error add address",
      );
      throw Exception('Failed to add address');
    }
  }

  Future<APIResponse> deleteAddress(int id) async {
    print("token ---${utils.token}");
    print("id ---$id");
    try {
      final response = await http.delete(
        Uri.https(baseUrl, '/api/v1/user_address/delete/$id'),
        headers: {
          'Content-Type': 'application/json',
          'Accept': 'application/json',
          'Authorization': 'Bearer ${utils.token}',
        },
      );
      print("----------------------------${response.body}");

      if (response.statusCode == 200) {
        print("response.statusCode ---${response.statusCode}");
        return APIResponse(
          statusCode: response.statusCode,
          dataJson: response.body,
        );
      } else {
        return APIResponse(
          statusCode: response.statusCode,
          errorMessage: 'Failed to delete address: ${response.reasonPhrase}',
          dataJson: response.body,
        );
      }
    } catch (e) {
      return APIResponse(
        statusCode: null,
        errorMessage: 'Exception: $e',
      );
    }
  }
}