import { Injectable } from '@nestjs/common'
import { isEmpty } from 'lodash'

import { HttpService } from '../services/http'
import { SubscriptionTransaction } from '../models'

import { BaseRepository } from './base.repository'

const ATTRIBUTES = `
  id
  patient_id
  installments
  amount
  discount
  fee
  card_number
  status
  subscription_id
  due_at
  paid_at
  data
  payment_provider
  card_type
  installment_number
  payment_id
  error_code
  error_message
`

const INSERT = `
  mutation insertSubscriptionTransaction($subscriptionTransaction: subscription_transaction_insert_input!) {
    insert_subscription_transaction_one(object: $subscriptionTransaction) {
      id
    }
  }
`

const GET = `
  query subscriptionTransaction($id: uuid!) {
    subscription_transaction(where: {id: {_eq: $id}}) {
      ${ATTRIBUTES}
    }
  }
`

const FIND_BY_PATIENT = `
  query subscriptionTransaction($patientId: String!) {
    subscription_transaction(where: {patient_id: {_eq: $patientId}}, order_by: {paid_at: asc}) {
      ${ATTRIBUTES}
    }
  }
`

const COUNT_FAILED_BY_SUBSCRIPTION_AND_INSTALLMENT = `
query countFailedSubscriptionTransaction($subscriptionId: uuid!, $installmentNumber: Int!) {
  subscription_transaction_aggregate(where: {subscription_id: {_eq: $subscriptionId}, status: {_eq: "failed"}, installment_number: {_eq: $installmentNumber}}) {
    aggregate {
      count
    }
  }
}
`

const FIND_BY_SUBSCRIPTION = `
  query subscriptionTransaction($subscriptionId: uuid!) {
    subscription_transaction(where: {subscription_id: {_eq: $subscriptionId}}, order_by: {paid_at: asc}) {
      ${ATTRIBUTES}
    }
  }
`

const FIND_LAST_BY_SUBSCRIPTION = `
  query subscriptionTransaction($subscriptionId: uuid!) {
    subscription_transaction(where: {subscription_id: {_eq: $subscriptionId}, status: {_eq: "success"}}, order_by: {paid_at: desc}, limit: 1) {
      ${ATTRIBUTES}
    }
  }
`

@Injectable()
export class SubscriptionTransactionRepository extends BaseRepository {
  constructor(protected readonly httpService: HttpService) {
    super(httpService, 'subscription_transaction')
  }

  async create(subscriptionTransaction: SubscriptionTransaction): Promise<string> {
    const qv = {
      subscriptionTransaction: subscriptionTransaction.toPlain(),
    }
    const { errors, data } = await this.fetchGraphQL({
      body: { query: INSERT, variables: qv },
      throwErrors: false,
    })

    if (errors) throw new Error(errors.shift()?.message)

    return data.insert_subscription_transaction_one.id
  }

  async get(id: string): Promise<SubscriptionTransaction> {
    const { data, errors } = await this.fetchGraphQL({
      body: { query: GET, variables: { id } },
      throwErrors: false,
    })

    if (errors) throw new Error(errors.shift()?.message)

    return isEmpty(data.subscription_transaction)
      ? null
      : SubscriptionTransaction.toInstance(data.subscription_transaction[0])
  }

  async findByPatient(patientId: string): Promise<SubscriptionTransaction[]> {
    const { data, errors } = await this.fetchGraphQL({
      body: { query: FIND_BY_PATIENT, variables: { patientId } },
      throwErrors: false,
    })

    if (errors) throw new Error(errors.shift()?.message)

    return isEmpty(data.subscription_transaction)
      ? []
      : data.subscription_transaction.map(value => SubscriptionTransaction.toInstance(value))
  }

  async findBySubscription(subscriptionId: string): Promise<SubscriptionTransaction[]> {
    const { data, errors } = await this.fetchGraphQL({
      body: { query: FIND_BY_SUBSCRIPTION, variables: { subscriptionId } },
      throwErrors: false,
    })

    if (errors) throw new Error(errors.shift()?.message)

    return isEmpty(data.subscription_transaction)
      ? []
      : data.subscription_transaction.map(value => SubscriptionTransaction.toInstance(value))
  }

  async countFailedBySubscriptionIdAndInstallment(subscriptionId: string, installmentNumber: number): Promise<number> {
    const { data, errors } = await this.fetchGraphQL({
      body: { query: COUNT_FAILED_BY_SUBSCRIPTION_AND_INSTALLMENT, variables: { subscriptionId, installmentNumber } },
      throwErrors: false,
    })

    if (errors) throw new Error(errors.shift()?.message)

    return data.subscription_transaction_aggregate?.aggregate?.count
  }

  async findLastBySubscription(subscriptionId: string): Promise<SubscriptionTransaction> {
    const { data, errors } = await this.fetchGraphQL({
      body: { query: FIND_LAST_BY_SUBSCRIPTION, variables: { subscriptionId } },
      throwErrors: false,
    })

    if (errors) throw new Error(errors.shift()?.message)

    return isEmpty(data.subscription_transaction)
      ? null
      : SubscriptionTransaction.toInstance(data.subscription_transaction[0])
  }
}