import { Injectable } from '@nestjs/common'
import { classToPlain, plainToClass } from 'class-transformer'
import { endOfDay, startOfDay } from 'date-fns'

import { Message } from '../models/message.model'
import { HttpService } from '../services/http'

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

const USER_PENDING_MESSAGES_COUNT = `
  query userPendingMessagesCount($beginDate: timestamptz!, $endDate: timestamptz!, $userId: String) {
    message: pending_messages_aggregate(where: {user_id: {_eq: $userId}, sent_at: {_gte: $beginDate, _lte: $endDate}}){
      aggregate {
        count
      }
    }
  }
`

const FIND_USER_PENDING_MESSAGES = `
  query userPendingMessages($beginDate: timestamptz!, $endDate: timestamptz!, $userId: String) {
    pending_messages (where: {user_id: {_eq: $userId}, sent_at: {_gte: $beginDate, _lte: $endDate}}){
      id
      user_id
      patient_id
      sent_at
      view_at
      replied_by_user_id
    }
  }
`

const FIND_PATIENT_PENDING_MESSAGES = `
  query patientPendingMessages($patientId: String) {
    pending_messages (where: {patient_id: {_eq: $patientId}}){
      id
      user_id
      patient_id
      sent_at
      view_at
      replied_by_user_id
    }
  }
`

const TRANSFER_MESSAGES = `
  mutation transferPendingMessages($userId: String!, $ids: [uuid!]!) {
    update_message(_set: {user_id: $userId}, where: {id: {_in: $ids}}) {
      returning {
        id
      }
    }
  }
`

const USER_PATIENT_PENDING_MESSAGES_COUNT = `
  query getTotalUserPatientPendingMessages($userId: String!, $patientId: String!) {
    message: message_aggregate(where: {user_id: {_eq: $userId}, patient_id: {_eq: $patientId}, view_at: {_is_null: true}}) {
      aggregate {
        count
      }
    }
  }
`

const INSERT = `
  mutation insert_message($object: message_insert_input!) {
    insert_message_one(object: $object) { id }
  }
`

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

  async getUserPendingMessagesCount(beginDate: Date, endDate: Date, userId: string): Promise<number> {
    const { data } = await this.fetchGraphQL({
      body: {
        query: USER_PENDING_MESSAGES_COUNT,
        variables: { beginDate: startOfDay(beginDate), endDate: endOfDay(endDate), userId },
      },
    })

    return data?.message?.aggregate?.count || 0
  }

  async findUserPendingMessages(beginDate: Date, endDate: Date, userId: string): Promise<Message[]> {
    const { data } = await this.fetchGraphQL({
      body: {
        query: FIND_USER_PENDING_MESSAGES,
        variables: { beginDate: startOfDay(beginDate), endDate: endOfDay(endDate), userId },
      },
    })

    return data?.message?.map(row => plainToClass(Message, row)) || []
  }

  async findPatientPendingMessages(patientId: string): Promise<Message[]> {
    const { data } = await this.fetchGraphQL({
      body: {
        query: FIND_PATIENT_PENDING_MESSAGES,
        variables: { patientId },
      },
    })

    return data?.message?.map(row => plainToClass(Message, row)) || []
  }

  async transferPatientPendingMessages(patientId: string, userId: string): Promise<void> {
    const messageIds = (await this.findPatientPendingMessages(patientId)).map(message => message.id)

    await this.fetchGraphQL({
      body: {
        query: TRANSFER_MESSAGES,
        variables: { userId, ids: messageIds },
      },
    })
  }

  async getUserPatientPendingMessagesCount(userId: string, patientId: string): Promise<number> {
    const { data } = await this.fetchGraphQL({
      body: {
        query: USER_PATIENT_PENDING_MESSAGES_COUNT,
        variables: { userId, patientId },
      },
    })

    return data?.message?.aggregate?.count || 0
  }

  async create(message: Message): Promise<{ id: string }> {
    const object = classToPlain(message)

    const { data } = await this.fetchGraphQL({
      body: { query: INSERT, variables: { object } },
    })

    return data.insert_message_one
  }
}