suspend fun emailRegisteredCheck(email: String): ApiResponse<ResponseBody>

CoroutineScope(Dispatchers.IO).launch {
   val apiResponse = apiRepository.emailRegisteredCheck(email)
   withContext(Dispatchers.Main) {
       when (apiResponse) {
           is ApiSuccessResponse -> {
               //navigateToPasswordScreen
           }
           is ApiErrorResponse -> {
               when(apiResponse.errorCode) {
                   404 -> {
                       // navigate to new registration screen
                   }
                   else -> {
                       // show error
                   }
               }
           }
       }
   }
}

suspend fun registerNewUser(user: WLRegisterNewUserModel): ApiResponse<LoginResponse>

val registerNewUserModel = WLRegisterNewUserModel(
   email = "123@123.com",
   password = "123",
   firstName = "123",
   lastName = "123",
   country = "US",
   ………
)

CoroutineScope(Dispatchers.IO).launch {
   val apiResponse = apiRepository.registerNewUser(user)
   withContext(Dispatchers.Main) {
       when (apiResponse) {
           is ApiSuccessResponse -> {
               apiResponse.data?.let { result ->
                   // registration successful
               }
           }

           is ApiErrorResponse -> {
               _success.value = false
               if (apiResponse.errorCode == 409) {
                   // email exists..
               }
               // show error
           }
       }
   }
}

suspend fun getTokenViaUserPassword(username: String, password: String): ApiResponse<LoginResponse>

CoroutineScope(Dispatchers.IO).launch {
   val apiResponse = apiRepository.getTokenViaUserPassword(email, password)
   withContext(Dispatchers.Main) {
       when (apiResponse) {
           is ApiSuccessResponse -> {
               apiResponse.data?.let { result ->
                   // login successful
               }
           }

           is ApiErrorResponse -> {
               // show error
           }
       }
   }
}

suspend fun recoverLostPassword(email: String): ApiResponse<ResponseBody>

CoroutineScope(Dispatchers.IO).launch {
   val apiResponse = apiRepository.recoverLostPassword(email)
   withContext(Dispatchers.Main) {
       when (apiResponse) {
           is ApiSuccessResponse -> {
               // show message: An email has been sent. Please check this to reset your password, then try logging in again.
           }
           is ApiErrorResponse -> {
               // show error
           }
       }
   }
}

suspend fun getVoucherByVoucherCode(
   voucherCode: String,
   model: String
): ApiResponse<VoucherDetail>

CoroutineScope(Dispatchers.IO).launch {
   val apiResponse = apiRepository.getVoucherByVoucherCode(code.text.formatVoucherCode(), Build.MODEL)
   withContext(Dispatchers.Main) {
       when (apiResponse) {
           is ApiSuccessResponse -> {
               apiResponse.data?.let { result ->

                   // configure required tests(including sensor test)
                   // configure case brand and models
                   // configure demographics & driving survey questions
                   // get ddd offers
                   // check SOAP(Smart saver on Annual Plans): details can be found: here
                   // SOAP example codes:


                   if(result.isClaimed == true && result.voucherItem != null) {
                       if(isSameDevice) {
                           // yes: make an update to the Item rather than create a new one
                           // check current app user and warranty owner
                       } else if(result.isDeviceTransferrable == true) {
                           // yes:  create a new Item instead of updating the existing Item
                           // check current app user and warranty owner
                       } else {
                           // show deny user alert - Sorry, this warranty can only be used on the device for which it was originally purchased.
                       }
                   }
               }
           }
           is ApiErrorResponse -> {
               when(apiResponse.errorCode) {
                   403 -> _showVoucherAlreadyClaimed
                   404 -> _showVoucherDoseNotExist
                   else -> {
                       // show error
                   }
               }
           }
       }
   }
}

suspend fun createItem(item: WLCreateItemModel): ApiResponse<CreateItemResponse>

val createItemModel = WLCreateItemModel(
   deviceId = "test",
   serialNumber = "551122662626272",
   categoryId = "96", // const val TABLET_DEVICE_ID = 93, const val PHONE_DEVICE_ID = 96
   manufacturerName = "Google",
   model = "Pixel 6",
   mpn = "Pixel 6"
)

CoroutineScope(Dispatchers.IO).launch {
   val apiResponse = apiRepository.createItem(item)
   withContext(Dispatchers.Main) {
       when (apiResponse) {
           is ApiSuccessResponse -> {
               apiResponse.data?.let { result ->
                   // make create diagnostic report call
               }
           }
           is ApiErrorResponse -> {
               // show error
           }
       }
   }
}

suspend fun createItemDiagnosticReport(
   itemID: String,
   deviceDiagnosticData: MutableMap
): ApiResponse<DiagnosticReport>

val diagnosticDetails = mutableMapOf<String, Any?>()
diagnosticDetails.put("imei", "{device_imei_number}")
…
// add all the diagnostic details in the hashmap
CoroutineScope(Dispatchers.IO).launch {
   val apiResponse = apiRepository.createItemDiagnosticReport(itemId, diagnosticDetails)
   withContext(Dispatchers.Main) {
       when (apiResponse) {
           is ApiSuccessResponse -> {
               apiResponse.data?.let { result ->
                   // upload images & send sensor test data
               }
           }
           is ApiErrorResponse -> {
               // show error
           }
       }
   }
}

suspend fun createSurvey(survey: HashMap<String, Object>) : ApiResponse<T>

val answers = arrayListOf<HashMap<String, Any>>()
val answer = hashMapOf<String, Any>()
answer["surveyQuestionId"] = 4
answer["chosenSurveyQuestionOptionId"] = 14
answers.add(answer)
…
// add all the question and answers details here

val survey = HashMap<String, Any>()
surveyData.put("surveyVersion", x)
surveyData.put("diagnosticId",  "ARgag3vrE1OVoF0OO-D6jaSQ");
surveyData.put("answers", answers);

coroutineScope.launch {
   when (val apiResponse = apiRepository.createSurvey(survey)) {
       is ApiSuccessResponse -> {
           // success
       }
       is ApiErrorResponse -> {
           // show error popup
       }
   }
}

const val SUBJECT_SP_SOUND = "sound"
const val SUBJECT_FRONT = "front"
const val SUBJECT_SP_REFERENCE = "reference"
const val SUBJECT_SP_TEST = "test"
const val SUBJECT_BACK = "back"
const val SUBJECT_SP_RECEIPT = "receipt"

suspend fun uploadImageForItem(
   registeredItemID: String,
   diagnosticDataRegistryID: String,
   image: MultipartBody.Part,
   subject: String
): ApiResponse<ResponseBody>

suspend fun uploadImageForReference(
   registeredItemID: String,
   diagnosticDataRegistryID: String,
   image: MultipartBody.Part,
   subject: String
): ApiResponse<ResponseBody>

val fileBody: RequestBody = file.asRequestBody("multipart/form-data".toMediaTypeOrNull())
val filePart: MultipartBody.Part = MultipartBody.Part.createFormData("file", imageFile.name, fileBody)

// can be launched in a separate asynchronous job
CoroutineScope(Dispatchers.IO).launch {
   val apiResponse = apiRepository.uploadImageForItem(itemId, diagnosticId, filePart, SUBJECT_FRONT)
   withContext(Dispatchers.Main) {
       when (apiResponse) {
           is ApiSuccessResponse -> {
               // image uploaded
           }
           is ApiErrorResponse -> {
               // show error
           }
       }
   }
}

// Use this function to upload sound clip
suspend fun uploadSoundClips(
   itemID: String,
   derivativeTypeId: String,
   timeStamp: String,
   sound: MultipartBody.Part
): ApiResponse<ResponseBody>


// Use this function to upload sensor reading data
suspend fun uploadSensorReadings(
   itemID: String,
   sensorEventID: String,
   dropReadings: List<Any?>
): ApiResponse<ResponseBody>

// Implementation to upload sound clip

val fileBody: RequestBody = wavFile.asRequestBody("audio/x-wav".toMediaTypeOrNull())
val filePart: MultipartBody.Part = MultipartBody.Part.createFormData("audio", wavFile.name, fileBody)


// can be launched in a separate asynchronous job
CoroutineScope(Dispatchers.IO).launch {
   val apiResponse = apiRepository.uploadSoundClips(itemId, eventId, soundTime, filePart)
   withContext(Dispatchers.Main) {
       when (apiResponse) {
           is ApiSuccessResponse -> {
               apiResponse.data?.let { result ->
                   // if the sensor event is case detection test during registration then check if receipt is required,
                   // if yes then go to Activation Details view, if not then check if skipRegistrationForm,
                   // if yes then go to Owner Registration Details view, if not then go to Date Of Purchase view
               }
           }
           is ApiErrorResponse -> {
               // show error
           }
       }
   }
}

// Implementation to upload sensor reading
CoroutineScope(Dispatchers.IO).launch {
   val apiResponse = apiRepository.uploadSensorReadings(itemId, sensorEventId, readings)
   withContext(Dispatchers.Main) {
       when (apiResponse) {
           is ApiSuccessResponse -> {
               // if the sensor event is case detection test during registration then check if receipt is required,
               // if yes then go to Activation Details view, if not then check if skipRegistrationForm,
               // if yes then go to Owner Registration Details view, if not then go to Date Of Purchase view
           }
           is ApiErrorResponse -> {
               // show error
           }
       }
   }
}

// sensorEventType values
const val CASE_DETECTION_TEST_DURING_REGISTRATION = "1111"
const val SSR_KEEP_ENABLED = "1060"
const val SSR_ENABLED = "1000"
const val SSR_DISABLED = "1050"


const val SSD_KEEP_ENABLED = "6060"
const val SSD_ENABLED = "6010"
const val SSD_DISABLED = "6086"

const val HEARTBEAT_INSTALLED = "300"
const val HEARTBEAT_STARTED = "330"
const val HEARTBEAT_HEARTBEAT = "333"
const val HEARTBEAT_DEVICEOFF = "340"
const val HEARTBEAT_TERMINATED = "341"
const val HEARTBEAT_LOGOUT = "384"

suspend fun createSensorEvent(deviceID: String, body: MutableMap<String, Any>): ApiResponse<UpdateItemResponse>

val eventData = HashMap<String, Any>()
eventData["appVersion"] = BuildConfig.VERSION_CODE.toString()
eventData["dropJsVersion"] = dropJsVersion
eventData["platformVersion"] = Build.VERSION.RELEASE
eventData["eventAt"] = getCurrentFullDate() // "yyyy-MM-dd HH:mm:ss.SSS"
eventData["sensorEventType"] = eventType // For ex, use “1000” for SSR enabled


CoroutineScope(Dispatchers.IO).launch {
   val apiResponse = apiRepository.createSensorEvent(itemId, eventData)
   withContext(Dispatchers.Main) {
       when (apiResponse) {
           is ApiSuccessResponse -> {
               apiResponse.data?.let { result ->
                   // returns “sensorEventId“, use this field to make upload Sensor Readings call
               }
           }
           is ApiErrorResponse -> {
               // show error
           }
       }
   }
}

suspend fun getItemByDeviceID(deviceId: String): ApiResponse<ItemByDeviceIdResponse>

CoroutineScope(Dispatchers.IO).launch {
   val apiResponse = apiRepository.getItemByDeviceID(deviceId)
   withContext(Dispatchers.Main) {
       when (apiResponse) {
           is ApiSuccessResponse -> {
               // check if device is covered under warranty & isSsrEnabled
           }

           is ApiErrorResponse -> {
               // show error
           }
       }
   }
}

suspend fun getItemByDeviceIdPublic(deviceId: String): ApiResponse<DeviceDetail>

CoroutineScope(Dispatchers.IO).launch {
   val apiResponse = apiRepository.getItemByDeviceIdPublic(deviceId)
   withContext(Dispatchers.Main) {
       when (apiResponse) {
           is ApiSuccessResponse -> {
               // device exists, need to save 'ownerEmailHint' returned from the call
           }

           is ApiErrorResponse -> {
               // show error
           }
       }
   }
}

suspend fun createWarranty(wlCreateWarrantyModel: WLCreateWarrantyModel): ApiResponse<Warranty>

CoroutineScope(Dispatchers.IO).launch {
   val apiResponse = apiRepository.createWarranty(wlCreateWarrantyModel)
   withContext(Dispatchers.Main) {
       when (apiResponse) {
           is ApiSuccessResponse -> {
               apiResponse.data?.run {
                   // enable DDD if SmartSaver is available & user accepted & granted all required permissions
                   // go to offers screen if ssd is enabled, else go to registration details screen
               }
           }
           is ApiErrorResponse -> {
               // show error
           }
       }
   }
}

suspend fun getWarrantyById(warrantyId: String): ApiResponse<Warranty>

CoroutineScope(Dispatchers.IO).launch {
   val apiResponse = apiRepository.getWarrantyById(warrantyId)
   withContext(Dispatchers.Main) {
       when (apiResponse) {
           is ApiSuccessResponse -> {
               apiResponse.data?.let { result ->
                  // success
               }
           }
           is ApiErrorResponse -> {
              // show error
           }
       }
   }
}

suspend fun updateWarranty(wlCreateWarrantyModel: WLCreateWarrantyModel): ApiResponse<Warranty>

CoroutineScope(Dispatchers.IO).launch {
   val apiResponse = apiRepository.updateWarranty(getWLCreateWarrantyModel())
   withContext(Dispatchers.Main) {
       when (apiResponse) {
           is ApiSuccessResponse -> {
               apiResponse.data?.run {
                   // updated successfully
               }
           }
           is ApiErrorResponse -> {
               // show error
           }
       }
   }
}

suspend fun getAppConfig(): ApiResponse<AppConfig>

CoroutineScope(Dispatchers.IO).launch {
   val apiResponse = apiRepository.getAppConfig()
   withContext(Dispatchers.Main) {
       when (apiResponse) {
           is ApiSuccessResponse -> {
               // list of countries and states
           }
           is ApiErrorResponse -> {
               // show error
           }
       }
   }
}

updateFCMToken(itemId: String, deviceID: String, fcmToken: String): ApiResponse<ResponseBody>

CoroutineScope(Dispatchers.IO).launch {
   val apiResponse = apiRepository.updateFCMToken(preferenceManager.getItemID(), deviceId, fcmToken)
   withContext(Dispatchers.Main) {
       when (apiResponse) {
           is ApiSuccessResponse -> {
               // success
           }
           is ApiErrorResponse -> {
               // failure
           }
       }
   }
}

const val CLIENT_CODE_NOT_FOUND = "Please set client code provided by Warranty Life"
const val SENTRY_DSN_NOT_FOUND = "Please set Sentry client key(DSN)"
const val SDK_BUILD_ERROR = "SDK is failed to build"

class ApiErrorResponse<T>(val error: String, val errorMessage: String?, val errorCode: Int): ApiResponse<T>()