package com.onurway.ui.main.trip.model

import android.content.Context
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import com.google.android.gms.maps.model.LatLng
import com.onurway.R
import com.onurway.shared.data.address.data.remote.model.AddressDataModel
import com.onurway.shared.data.remote.Result
import com.onurway.shared.data.ticket.data.remote.model.TicketResponse
import com.onurway.shared.data.trip.data.TripRepository
import com.onurway.shared.data.trip.data.model.NodeDataModel
import com.onurway.shared.data.trip.data.model.TicketDataModel
import com.onurway.shared.data.trip.data.model.TripDataModel
import com.onurway.shared.data.trip.data.remote.model.TripResponse
import com.onurway.shared.utils.CoroutinesDispatcherProvider
import com.onurway.shared.utils.TimeUtils
import com.onurway.shared.utils.event.Event
import com.onurway.shared.utils.formatAddress
import com.onurway.shared.utils.formatCarTitle
import com.onurway.shared.utils.formatCost
import com.onurway.shared.utils.formatSeats
import com.onurway.shared.utils.formatUserName
import com.onurway.shared.utils.network.ApiCallErrors
import com.onurway.util.BaseViewModel
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Job
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import kotlin.math.max
import kotlin.math.min

class TripViewModel(
  private val context: Context,
  private val tripRepository: TripRepository,
  private val dispatcherProvider: CoroutinesDispatcherProvider
): BaseViewModel() {
  private val parentJob = Job()
  private val scope = CoroutineScope(dispatcherProvider.main + parentJob)
  private val inflight = mutableMapOf<String, Job>()

  private val _uiState = MutableLiveData<UiModel>()
  val uiState: LiveData<UiModel>
    get() = _uiState

  lateinit var trip: TripDataModel

  private val _bookingModel = MutableLiveData<BookingModel>()
  val bookingModel: LiveData<BookingModel>
    get() = _bookingModel

  fun getRemoteTrip(tripId: Long, searchPickupAddressId: Long, searchDropoffAddressId: Long) {
    val id = "REMOTE_TRIP"
    if (inflight[id]?.isActive == true) inflight[id]?.cancel()
    inflight[id] = launchRemoteTrip(tripId, searchPickupAddressId, searchDropoffAddressId)
  }

  fun book() {
    val id = "BOOK_TRIP"
    if (inflight[id]?.isActive == true) inflight[id]?.cancel()
    inflight[id] = launchBookTrip()
  }

  private fun launchRemoteTrip(tripId: Long, searchPickupAddressId: Long, searchDropoffAddressId: Long): Job {
    return scope.launch(dispatcherProvider.io) {
      val result = tripRepository.remoteTrip(tripId)
      withContext(dispatcherProvider.main) {
        when (result) {
          is Result.Success -> {
            val document = result.data
            trip = TripDataModel.fromTripResponse(
              document,
              document.asObjectDocument<TripResponse>().get(), searchPickupAddressId, searchDropoffAddressId
            )
            emitUiState(showSuccess = TripViewDataModel.fromTripDataModel(context, trip))
          }
          is Result.Error -> {
            emitUiState(
              showError = Event(nonApiErrorMessage(result, message = R.string.generic_network_error))
            )
          }
          is Result.ApiError -> {
            emitUiState(showApiErrors = Event(result.apiErrors))
          }
        }
      }
    }
  }

  private fun launchBookTrip(): Job {
    return scope.launch(dispatcherProvider.io) {
      val ticket = bookingModel.value?.toTicketDataModel()
      ticket ?: return@launch
      val result = tripRepository.bookTrip(trip.id, ticket)
      withContext(dispatcherProvider.main) {
        when (result) {
          is Result.Success -> {
            emitUiState(showBookingSuccess = Event(result.data))
          }
          is Result.Error -> {
            emitUiState(
              showError = Event(nonApiErrorMessage(result, message = R.string.generic_network_error))
            )
          }
          is Result.ApiError -> {
            emitUiState(showApiErrors = Event(result.apiErrors))
          }
        }
      }
    }
  }

  fun isTripInitialized() = ::trip.isInitialized

  fun isBookingPickupPointPickerRequired() =
    trip.essentialPickupPoint.serving == true || trip.hasMultipleNodesInPickupPointCity()

  fun isBookingDropoffPointPickerRequired() =
    trip.essentialDropoffPoint.serving == true || trip.hasMultipleNodesInDropoffPointCity()

  fun initBookingModel() {
    _bookingModel.value = BookingModel.fromTrip(trip)
  }

  fun isUserBooked(userId: Long) = trip.tickets.any { it.passengerId == userId }

  fun initBookingPickupCords(): LatLng? {
    val userAddress = bookingModel.value?.userPickupAddress
    var lat = userAddress?.latitude
    var lng = userAddress?.longitude
    return  if (lat != null && lng != null)
      LatLng(lat, lng)
    else {
      val tripPickupAddress = trip.essentialPickupPoint
      lat = tripPickupAddress.addressLatitude
      lng = tripPickupAddress.addressLongitude
      if (lat != null && lng != null)
        LatLng(lat, lng)
      else null
    }
  }

  fun initBookingDropoffCords(): LatLng? {
    val userAddress = bookingModel.value?.userDropoffAddress
    var lat = userAddress?.latitude
    var lng = userAddress?.longitude
    return  if (lat != null && lng != null)
      LatLng(lat, lng)
    else {
      val tripDropoffAddress = trip.essentialDropoffPoint
      lat = tripDropoffAddress.addressLatitude
      lng = tripDropoffAddress.addressLongitude
      if (lat != null && lng != null)
        LatLng(lat, lng)
      else null
    }
  }

  fun defaultLatLng() = LatLng(34.023882, 36.728373)

  fun onBookingSeatsChanged(newSeats: Int) {
    val booking = _bookingModel.value
    if (newSeats > 0 && newSeats <= (trip.availableSeats ?: 1)) booking?.seats = newSeats
    _bookingModel.value = booking
  }

  fun onBookingPickupPointChanged(id: Long) {
    val booking = _bookingModel.value
    val newPickupPoint = trip.nodes.find { it.id == id } ?: return
    booking?.tripPickupPoint = newPickupPoint
    _bookingModel.value = booking
  }

  fun onBookingDropoffPointChanged(id: Long) {
    val booking = _bookingModel.value
    val newDropoffPoint = trip.nodes.find { it.id == id } ?: return
    booking?.tripDropoffPoint = newDropoffPoint
    _bookingModel.value = booking
  }

  fun onUserPickupPointChanged(
    location: String? = bookingModel.value?.userPickupAddress?.location,
    latitude: Double? = bookingModel.value?.userPickupAddress?.latitude,
    longitude: Double? = bookingModel.value?.userPickupAddress?.longitude
  ) {
    val booking = _bookingModel.value
    booking?.updateUserPickupAddress(trip.essentialPickupPoint.addressCity, location, latitude, longitude)
    _bookingModel.value = booking
  }

  fun onUserDropoffPointChanged(
    location: String? = bookingModel.value?.userDropoffAddress?.location,
    latitude: Double? = bookingModel.value?.userDropoffAddress?.latitude,
    longitude: Double? = bookingModel.value?.userDropoffAddress?.longitude
  ) {
    val booking = _bookingModel.value
    booking?.updateUserDropoffAddress(trip.essentialDropoffPoint.addressCity, location, latitude, longitude)
    _bookingModel.value = booking
  }

  data class UiModel(
    val showSuccess: TripViewDataModel? = null,
    val showBookingSuccess: Event<TicketResponse>? = null,
    val showProgress: Boolean,
    val showError: Event<Int>? = null,
    val showApiErrors: Event<ApiCallErrors>? = null
  ) {
    fun hasBookingGenericErrors() =
      showApiErrors?.peek()?.filterOutBySources(
        true, *TripViewModel.BOOKING_ERROR_ATTRIBUTES
      )?.isNotEmpty() ?: false

    // TODO: cache errors (filtering is called twice in both hasGenericErrors and genericErrors)
    fun bookingGenericErrors() =
      showApiErrors
        ?.peek()
        ?.filterOutBySources(true, *TripViewModel.BOOKING_ERROR_ATTRIBUTES)
        ?.joinToString(separator = "\n") { it.title }

    fun hasBookingFieldErrors(field: String) =
      showApiErrors?.peek()?.filterBySources(true, field)?.isNotEmpty() ?: false

    fun bookingFieldErrors(field: String) =
      showApiErrors
        ?.peek()
        ?.filterBySources(true, field)
        ?.joinToString(separator = "\n") { it.title }
  }

  private fun emitUiState(
    showSuccess: TripViewDataModel? = null,
    showBookingSuccess: Event<TicketResponse>? = null,
    showProgress: Boolean = false,
    showError: Event<Int>? = null,
    showApiErrors: Event<ApiCallErrors>? = null
  ) {
    val uiModel = UiModel(
      showSuccess,
      showBookingSuccess,
      showProgress,
      showError,
      showApiErrors
    )
    _uiState.value = uiModel
  }

  data class TripViewDataModel(
    val pickupDate: String?,
    val cost: String,
    val availableSeats: String?,
    val details: String?,
    val backSeatsForFemales: Boolean?,
    val driverFullName: String?,
    val driverPictureUrl: String?,
    val carTitle: String?,
    val carColor: String?,
    val nodes: List<NodeViewDataModel>,
    val tickets: List<TicketViewDataModel>
  ) {
    companion object {
      fun fromTripDataModel(context: Context, tripDataModel: TripDataModel): TripViewDataModel {
        val separator = context.getString(R.string.address_separator)
        return TripViewDataModel(
          pickupDate= tripDataModel.pickupDate?.let { TimeUtils.formatLocalDate(it, "EEEE dd LLLL") },
          cost = formatCost(tripDataModel.cost, context.getString(R.string.trip_money_unit))!!,
          availableSeats = formatSeats(tripDataModel.availableSeats, context.getString(R.string.trip_seats_available)),
          details = tripDataModel.details,
          backSeatsForFemales =  tripDataModel.backSeatsForFemales,
          driverFullName = formatUserName(tripDataModel.driverFirstName, tripDataModel.driverLastName),
          driverPictureUrl = tripDataModel.driverPictureUrl,
          carTitle =
          formatCarTitle(tripDataModel.carMake, tripDataModel.carModel),
          carColor = tripDataModel.carColor,
          nodes = tripDataModel.nodes.map {
            NodeViewDataModel.fromNodeDataModel(it, separator)
          }.apply {
            find { it.id == tripDataModel.essentialPickupPoint.id }?.isEssentialPickupPoint = true
            find { it.id == tripDataModel.essentialDropoffPoint.id }?.isEssentialDropoffPoint = true
          },
          tickets = tripDataModel.tickets.map {
            TicketViewDataModel.fromTicketDataModel(it, separator)
          }
        )
      }
    }
  }

  data class NodeViewDataModel(
    val id: Long?,
    val pickupAt: String?,
    val address: String?,
    val serving: Boolean?,
    val availableSeats: Int,
    val inEssentialPath: Boolean,
    var isEssentialPickupPoint: Boolean = false,
    var isEssentialDropoffPoint: Boolean = false,
    val bookable: Boolean?
  ) {
    companion object {
      fun fromNodeDataModel(nodeDataModel: NodeDataModel, separator: String): NodeViewDataModel {
        return NodeViewDataModel(
          id = nodeDataModel.id,
          pickupAt = nodeDataModel.pickupAt?.let { TimeUtils.formatInstantAsTime(it) },
          address = formatAddress(nodeDataModel.addressCity, nodeDataModel.addressLocation, separator),
          serving = nodeDataModel.serving,
          availableSeats = nodeDataModel.availableSeats,
          inEssentialPath = nodeDataModel.inEssentialPath,
          bookable = nodeDataModel.bookable
        )
      }
    }
  }

  data class TicketViewDataModel(
    val passengerFullName: String?,
    val passengerPictureUrl: String?,
    val pickupAddress: String?,
    val dropoffAddress: String?
  ) {
    companion object {
      fun fromTicketDataModel(ticketDataModel: TicketDataModel, separator: String): TicketViewDataModel {
        return TicketViewDataModel(
          passengerFullName = formatUserName(ticketDataModel.passengerFirstName, ticketDataModel.passengerLastName),
          passengerPictureUrl = ticketDataModel.passengerPictureUrl,
          pickupAddress =
          formatAddress(ticketDataModel.pickupAddressCity, ticketDataModel.pickupAddressLocation, separator),
          dropoffAddress =
          formatAddress(ticketDataModel.dropoffAddressCity, ticketDataModel.dropoffAddressLocation, separator)
        )
      }
    }
  }

  data class BookingModel(
    var tripPickupPoint: NodeDataModel,
    var tripDropoffPoint: NodeDataModel,
    var userPickupAddress: AddressDataModel?,
    var userDropoffAddress: AddressDataModel?,
    var seats: Int
  ) {
    fun updateUserPickupAddress(city: String?, location: String? = null, latitude: Double? = null, longitude: Double? = null) {
      if (userPickupAddress == null)
        userPickupAddress = AddressDataModel(
          city = city,
          location = location,
          latitude = latitude,
          longitude = longitude
        )
      else
        userPickupAddress?.let {
          it.city = city
          it.location = location
          it.latitude = latitude
          it.longitude = longitude
        }
    }

    fun updateUserDropoffAddress(city: String?, location: String? = null, latitude: Double? = null, longitude: Double? = null) {
      if (userDropoffAddress == null)
        userDropoffAddress = AddressDataModel(
          city = city,
          location = location,
          latitude = latitude,
          longitude = longitude
        )
      else
        userDropoffAddress?.let {
          it.city = city
          it.location = location
          it.latitude = latitude
          it.longitude = longitude
        }
    }

    fun availableSeats(trip: TripDataModel): Int {
      val pps = trip.allPickupPoints()
      val essentialPps = pps.subList(pps.indexOf(tripPickupPoint), pps.size)
      val dps = trip.allDropoffPoints()
      val essentialDps = dps.subList(0, dps.indexOf(tripDropoffPoint) + 1)
      return min(
        max(essentialPps.map { it.availableSeats }.min() ?: 1, 1),
        max(essentialDps.map { it.availableSeats }.min() ?: 1, 1)
      )
    }

    fun toTicketDataModel(): com.onurway.shared.data.ticket.data.remote.model.TicketDataModel? {
      val pickUpPointId = tripPickupPoint.id
      val dropoffPointId = tripDropoffPoint.id
      if (pickUpPointId == null || dropoffPointId == null) return null
      return com.onurway.shared.data.ticket.data.remote.model.TicketDataModel(
        pickup_point_id = pickUpPointId,
        dropoff_point_id = dropoffPointId,
        seats = seats,
        custom_pickup_point_attributes = userPickupAddress,
        custom_dropoff_point_attributes = userDropoffAddress
      )
    }

    companion object {
      fun fromTrip(trip: TripDataModel): BookingModel {
        return BookingModel(
          tripPickupPoint = trip.essentialPickupPoint,
          tripDropoffPoint = trip.essentialDropoffPoint,
          userPickupAddress = null,
          userDropoffAddress = null,
          seats = 1
        )
      }
    }
  }

  companion object {
    const val ERROR_BOOKING_SEATS = "seats"
    val BOOKING_ERROR_ATTRIBUTES = arrayOf(ERROR_BOOKING_SEATS)
  }
}