import 'dart:developer';

import 'package:dartz/dartz.dart';
import 'package:data_channel/data_channel.dart';
import 'package:dio/dio.dart';
import 'package:injectable/injectable.dart';

import '../../../common/api/api_client.dart';
import '../../../common/api/api_failure.dart';
import '../../../common/api/interceptors/sensitive_aware_log_interceptor.dart';
import '../../../common/function/app_function.dart';
import '../../../common/url/api_path.dart';
import '../../../domain/wallet/wallet.dart';
import '../wallet_dtos.dart';
import '../wallet_response.dart';

@injectable
class PinRemoteDataProvider {
  final ApiClient _apiClient;
  final String _logName = 'PinRemoteDataProvider';

  PinRemoteDataProvider(this._apiClient);

  Future<DC<WalletFailure, PinStatusDto>> fetchStatus() => _request(
    'fetchStatus',
    () => _apiClient.get(ApiPath.pinStatus, headers: getAuthorizationHeader()),
    (response) => PinStatusDto.fromJson(walletDataOf(response)),
  );

  Future<DC<WalletFailure, PinOtpDto>> requestOtp(PinOtpPurpose purpose) =>
      _request(
        'requestOtp',
        () => _apiClient.post(
          ApiPath.pinOtp,
          headers: getAuthorizationHeader(),
          data: {'purpose': purpose.apiValue},
        ),
        (response) => PinOtpDto.fromJson(walletDataOf(response)),
      );

  Future<DC<WalletFailure, PinStatusDto>> setup({
    required String otpToken,
    required String otpCode,
    required String pin,
    required String confirmPin,
  }) => _request(
    'setup',
    () => _apiClient.post(
      ApiPath.pin,
      headers: getAuthorizationHeader(),
      data: {
        'otp_token': otpToken,
        'otp_code': otpCode,
        'pin': pin,
        'confirm_pin': confirmPin,
      },
      extra: {kSensitiveRequest: true},
    ),
    (response) => PinStatusDto.fromJson(walletDataOf(response)),
  );

  Future<DC<WalletFailure, Unit>> change({
    required String oldPin,
    required String pin,
    required String confirmPin,
  }) => _request(
    'change',
    () => _apiClient.put(
      ApiPath.pin,
      headers: getAuthorizationHeader(),
      data: {'old_pin': oldPin, 'pin': pin, 'confirm_pin': confirmPin},
      extra: {kSensitiveRequest: true},
    ),
    (_) => unit,
  );

  Future<DC<WalletFailure, Unit>> reset({
    required String otpToken,
    required String otpCode,
    required String pin,
    required String confirmPin,
  }) => _request(
    'reset',
    () => _apiClient.post(
      ApiPath.pinReset,
      headers: getAuthorizationHeader(),
      data: {
        'otp_token': otpToken,
        'otp_code': otpCode,
        'pin': pin,
        'confirm_pin': confirmPin,
      },
      extra: {kSensitiveRequest: true},
    ),
    (_) => unit,
  );

  Future<DC<WalletFailure, T>> _request<T>(
    String name,
    Future<Response> Function() call,
    T Function(Response response) parse,
  ) async {
    try {
      final response = await call();
      final failure = parseWalletFailure(response);
      if (failure != null) return DC.error(failure);
      return DC.data(parse(response));
    } on ApiFailure catch (e, s) {
      log(name, name: _logName, error: e, stackTrace: s);
      return DC.error(WalletFailure.serverError(e));
    }
  }
}