import { Request, RequestHandler, NextFunction, Router } from 'express'
import { Controller } from '../types'
import NotFoundException from '../../exceptions/NotFoundException'
import jsonResponseMiddleware, {
  JsonResponse,
} from '../../middleware/jsonResponse.middleware'
import twitterService, { GenerateResult } from '../../services/twitterService'
import { PaginationConnection } from 'sequelize-cursor-pagination'
import { TweetData } from '../../db/models/Tweet'
import { MODIFY_TOKEN } from '../../constants'
// import apiKeyMiddleware from '../../middleware/apikey.middleware'

interface ImportPayload {
  token: string
  urls: string[]
}

interface TopPayload {
  token: string
  statusId: string
  top?: boolean
}

export default class TweetController implements Controller {
  public path = '/api/v1/tweet'
  public router = Router()

  constructor() {
    this.initializeRoutes()
  }

  private initializeRoutes(): void {
    this.router.get(
      '/list',
      // apiKeyMiddleware(),
      jsonResponseMiddleware,
      this.list as RequestHandler
    )
    this.router.post(
      '/import',
      // apiKeyMiddleware(),
      jsonResponseMiddleware,
      this.import as RequestHandler
    )
    this.router.post(
      '/top',
      // apiKeyMiddleware(),
      jsonResponseMiddleware,
      this.top as RequestHandler
    )
  }

  private list(
    request: Request<any, any, any, { after?: string }>,
    response: JsonResponse<PaginationConnection<TweetData>>,
    next: NextFunction
  ): void {
    const after = request.query.after
    twitterService
      .paginateTweetByOrder(after)
      .then((tweets) => {
        response.jsonSuccess(tweets)
      })
      .catch((e) => {
        response.status(500).jsonError('Server Error', 1010)
      })
  }

  private import(
    request: Request<any, any, ImportPayload>,
    response: JsonResponse<GenerateResult[]>,
    next: NextFunction
  ): void {
    const { urls, token } = request.body
    if (token !== MODIFY_TOKEN) {
      response.status(401).jsonError('Unauthorized', 1012)
      return
    }

    twitterService
      .bulkGenerateTweetsByPublishAPI(urls)
      .then((tweets) => {
        response.jsonSuccess(tweets)
      })
      .catch((e) => {
        response.status(500).jsonError('Server Error', 1011)
      })
  }

  private top(
    request: Request<any, any, TopPayload>,
    response: JsonResponse<boolean>,
    next: NextFunction
  ): void {
    const { statusId, top, token } = request.body
    if (token !== MODIFY_TOKEN) {
      response.status(401).jsonError('Unauthorized', 1012)
      return
    }

    twitterService
      .makeTweetTop(statusId, top)
      .then(() => {
        response.jsonSuccess(true)
      })
      .catch((e) => {
        response.status(500).jsonError('Server Error', 1014)
      })
  }
}