import { Injectable, Inject } from '@angular/core';
import { HttpClient } from '@angular/common/http';

import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';

import { _MODULE_CONFIG } from '../config/token';
import { ModuleConfig } from '../config/module-config';
import { UrlConfig } from '@ucap-webmessenger/core';
import { Urls } from '../config/urls';
import {
  RetrieveRequest,
  RetrieveResponse,
  encodeRetrieve,
  decodeRetrieveSend,
  decodeRetrieveReceive,
  decodeRetrieveReservation,
  RetrieveSearchRequest,
  decodeRetrieveSearch
} from '../apis/retrieve';
import {
  SendRequest,
  SendResponse,
  encodeSend,
  decodeSend
} from '../apis/send';
import {
  DetailRequest,
  DetailResponse,
  encodeDetail,
  decodeDetail,
  ReadRequest,
  ReadResponse,
  encodeRead,
  decodeRead,
  ReadCheckResponse,
  decodeReadCheck,
  CancelRequest,
  CancelResponse,
  encodeCancel,
  decodeCancel,
  CancelReservationRequest,
  CancelReservationResponse,
  encodeCancelReservation,
  decodeCancelReservation,
  RetrieveResourceFileRequest,
  RetrieveResourceFileResponse,
  encodeRetrieveResourceFile,
  decodeRetrieveResourceFile
} from '../apis/detail';
import { DelRequest, DelResponse, decodeDel, encodeDel } from '../apis/del';
import {
  SaveMyRequest,
  SaveMyResponse,
  encodeSaveMy,
  decodeSaveMy,
  RetrieveMyRequest,
  RetrieveMyResponse,
  encodeRetrieveMy,
  decodeRetrieveMy,
  DelMyRequest,
  DelMyResponse,
  encodeDelMy,
  decodeDelMy,
  EditMyRequest,
  EditMyResponse,
  encodeEditMy,
  decodeEditMy
} from '../apis/my-message';
import {
  EditReservationRequest,
  EditReservationResponse,
  encodeEditReservation,
  decodeEditReservation
} from '../apis/edit-reservation-ex';
import {
  SendCopyRequest,
  SendCopyResponse,
  encodeSendCopy,
  decodeSendCopy
} from '../apis/send-copy';
import {
  UnreadCountRequest,
  UnreadCountResponse,
  encodeUnreadCount,
  decodeUnreadCount
} from '../apis/unread-count';

@Injectable({
  providedIn: 'root'
})
export class MessageApiService {
  readonly urls: Urls;

  constructor(
    @Inject(_MODULE_CONFIG) private moduleConfig: ModuleConfig,
    private httpClient: HttpClient
  ) {
    this.urls = UrlConfig.getUrls(
      this.moduleConfig.hostConfig,
      this.moduleConfig.urls
    );
  }

  /** retrieve */
  public retrieveSendMessage(
    req: RetrieveRequest
  ): Observable<RetrieveResponse> {
    return this.httpClient
      .post<any>(
        this.urls.retrieveSendMessageList,
        {},
        {
          params: encodeRetrieve(req)
        }
      )
      .pipe(map(res => decodeRetrieveSend(res)));
  }
  public retrieveReceiveMessage(
    req: RetrieveRequest
  ): Observable<RetrieveResponse> {
    return this.httpClient
      .post<any>(
        this.urls.retrieveRecvMessageList,
        {},
        {
          params: encodeRetrieve(req)
        }
      )
      .pipe(map(res => decodeRetrieveReceive(res)));
  }
  public retrieveReservationMessage(
    req: RetrieveRequest
  ): Observable<RetrieveResponse> {
    return this.httpClient
      .post<any>(
        this.urls.retrieveReservationMessageList,
        {},
        {
          params: encodeRetrieve(req)
        }
      )
      .pipe(map(res => decodeRetrieveReservation(res)));
  }
  public retrieveSearchMessage(
    req: RetrieveSearchRequest
  ): Observable<RetrieveResponse> {
    return this.httpClient
      .post<any>(
        this.urls.retrieveSearchMessage,
        {},
        {
          params: encodeRetrieve(req)
        }
      )
      .pipe(map(res => decodeRetrieveSearch(res)));
  }

  /** send */
  public sendMessage(req: SendRequest): Observable<SendResponse> {
    return this.httpClient
      .post<any>(
        this.urls.sendNewMessage,
        {},
        {
          params: encodeSend(req)
        }
      )
      .pipe(map(res => decodeSend(res)));
  }

  /** detail */
  public detailMessage(req: DetailRequest): Observable<DetailResponse> {
    return this.httpClient
      .post<any>(
        this.urls.retrieveMessageDetail,
        {},
        {
          params: encodeDetail(req)
        }
      )
      .pipe(map(res => decodeDetail(res)));
  }
  public readMessage(req: ReadRequest): Observable<ReadResponse> {
    return this.httpClient
      .post<any>(
        this.urls.readMessage,
        {},
        {
          params: encodeRead(req)
        }
      )
      .pipe(map(res => decodeRead(res)));
  }
  public retrieveReadCheck(req: ReadRequest): Observable<ReadCheckResponse> {
    return this.httpClient
      .post<any>(
        this.urls.retrieveReadCheck,
        {},
        {
          params: encodeRead(req)
        }
      )
      .pipe(map(res => decodeReadCheck(res)));
  }
  public cancelMessage(req: CancelRequest): Observable<CancelResponse> {
    return this.httpClient
      .post<any>(
        this.urls.cancelMessage,
        {},
        {
          params: encodeCancel(req)
        }
      )
      .pipe(map(res => decodeCancel(res)));
  }
  public cancelReservationMessage(
    req: CancelReservationRequest
  ): Observable<CancelReservationResponse> {
    return this.httpClient
      .post<any>(
        this.urls.cancelReservationMessage,
        {},
        {
          params: encodeCancelReservation(req)
        }
      )
      .pipe(map(res => decodeCancelReservation(res)));
  }
  public retrieveResourceFile(
    req: RetrieveResourceFileRequest
  ): Observable<RetrieveResourceFileResponse> {
    return this.httpClient
      .post<any>(
        this.urls.retrieveResourceFile,
        {},
        {
          params: encodeRetrieveResourceFile(req)
        }
      )
      .pipe(map(res => decodeRetrieveResourceFile(res)));
  }

  /** del */
  public deleteMessage(req: DelRequest): Observable<DelResponse> {
    return this.httpClient
      .post<any>(
        this.urls.deleteMessage,
        {},
        {
          params: encodeDel(req)
        }
      )
      .pipe(map(res => decodeDel(res)));
  }

  /** save my message */
  public saveMyMessage(req: SaveMyRequest): Observable<SaveMyResponse> {
    return this.httpClient
      .post<any>(
        this.urls.saveMyMessage,
        {},
        {
          params: encodeSaveMy(req)
        }
      )
      .pipe(map(res => decodeSaveMy(res)));
  }
  public retrieveMyMessage(
    req: RetrieveMyRequest
  ): Observable<RetrieveMyResponse> {
    return this.httpClient
      .post<any>(
        this.urls.retrieveMyMessage,
        {},
        {
          params: encodeRetrieveMy(req)
        }
      )
      .pipe(map(res => decodeRetrieveMy(res)));
  }
  public deleteMyMessage(req: DelMyRequest): Observable<DelMyResponse> {
    return this.httpClient
      .post<any>(
        this.urls.deleteMyMessage,
        {},
        {
          params: encodeDelMy(req)
        }
      )
      .pipe(map(res => decodeDelMy(res)));
  }
  public editMyMessage(req: EditMyRequest): Observable<EditMyResponse> {
    return this.httpClient
      .post<any>(
        this.urls.editMyMessage,
        {},
        {
          params: encodeEditMy(req)
        }
      )
      .pipe(map(res => decodeEditMy(res)));
  }

  /** edit reservation */
  public editReservationMessageEx(
    req: EditReservationRequest
  ): Observable<EditReservationResponse> {
    return this.httpClient
      .post<any>(
        this.urls.editReservationMessageEx,
        {},
        {
          params: encodeEditReservation(req)
        }
      )
      .pipe(map(res => decodeEditReservation(res)));
  }

  /** send-copy(forward) */
  public sendCopyMessage(req: SendCopyRequest): Observable<SendCopyResponse> {
    return this.httpClient
      .post<any>(
        this.urls.sendCopyMessage,
        {},
        {
          params: encodeSendCopy(req)
        }
      )
      .pipe(map(res => decodeSendCopy(res)));
  }

  /** unread count */
  public retrieveUnreadCount(
    req: UnreadCountRequest
  ): Observable<UnreadCountResponse> {
    return this.httpClient
      .post<any>(
        this.urls.retrieveUnreadCount,
        {},
        {
          params: encodeUnreadCount(req)
        }
      )
      .pipe(map(res => decodeUnreadCount(res)));
  }
}