// import * as express from 'express'
// import * as Bluebird from 'bluebird'
// import * as Sequelize from 'sequelize'
//
// import { database as db } from '../../../initializers/database'
// import {
// REQUEST_ENDPOINT_ACTIONS,
// REQUEST_ENDPOINTS,
// REQUEST_VIDEO_EVENT_TYPES,
// REQUEST_VIDEO_QADU_TYPES
// } from '../../../initializers'
// import {
// checkSignature,
// signatureValidator,
// remoteVideosValidator,
// remoteQaduVideosValidator,
// remoteEventsVideosValidator
// } from '../../../middlewares'
// import { logger, retryTransactionWrapper, resetSequelizeInstance } from '../../../helpers'
// import { quickAndDirtyUpdatesVideoToFriends, fetchVideoChannelByHostAndUUID } from '../../../lib'
// import { PodInstance, VideoFileInstance } from '../../../models'
// import {
// RemoteVideoRequest,
// RemoteVideoCreateData,
// RemoteVideoUpdateData,
// RemoteVideoRemoveData,
// RemoteVideoReportAbuseData,
// RemoteQaduVideoRequest,
// RemoteQaduVideoData,
// RemoteVideoEventRequest,
// RemoteVideoEventData,
// RemoteVideoChannelCreateData,
// RemoteVideoChannelUpdateData,
// RemoteVideoChannelRemoveData,
// RemoteVideoAccountRemoveData,
// RemoteVideoAccountCreateData
// } from '../../../../shared'
// import { VideoInstance } from '../../../models/video/video-interface'
//
// const ENDPOINT_ACTIONS = REQUEST_ENDPOINT_ACTIONS[REQUEST_ENDPOINTS.VIDEOS]
//
// // Functions to call when processing a remote request
// // FIXME: use RemoteVideoRequestType as id type
// const functionsHash: { [ id: string ]: (...args) => Promise<any> } = {}
// functionsHash[ENDPOINT_ACTIONS.ADD_VIDEO] = addRemoteVideoRetryWrapper
// functionsHash[ENDPOINT_ACTIONS.UPDATE_VIDEO] = updateRemoteVideoRetryWrapper
// functionsHash[ENDPOINT_ACTIONS.REMOVE_VIDEO] = removeRemoteVideoRetryWrapper
// functionsHash[ENDPOINT_ACTIONS.ADD_CHANNEL] = addRemoteVideoChannelRetryWrapper
// functionsHash[ENDPOINT_ACTIONS.UPDATE_CHANNEL] = updateRemoteVideoChannelRetryWrapper
// functionsHash[ENDPOINT_ACTIONS.REMOVE_CHANNEL] = removeRemoteVideoChannelRetryWrapper
// functionsHash[ENDPOINT_ACTIONS.REPORT_ABUSE] = reportAbuseRemoteVideoRetryWrapper
// functionsHash[ENDPOINT_ACTIONS.ADD_ACCOUNT] = addRemoteVideoAccountRetryWrapper
// functionsHash[ENDPOINT_ACTIONS.REMOVE_ACCOUNT] = removeRemoteVideoAccountRetryWrapper
//
// const remoteVideosRouter = express.Router()
//
// remoteVideosRouter.post('/',
// signatureValidator,
// checkSignature,
// remoteVideosValidator,
// remoteVideos
// )
//
// remoteVideosRouter.post('/qadu',
// signatureValidator,
// checkSignature,
// remoteQaduVideosValidator,
// remoteVideosQadu
// )
//
// remoteVideosRouter.post('/events',
// signatureValidator,
// checkSignature,
// remoteEventsVideosValidator,
// remoteVideosEvents
// )
//
// // ---------------------------------------------------------------------------
//
// export {
// remoteVideosRouter
// }
//
// // ---------------------------------------------------------------------------
//
// function remoteVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
// const requests: RemoteVideoRequest[] = req.body.data
// const fromPod = res.locals.secure.pod
//
// // We need to process in the same order to keep consistency
// Bluebird.each(requests, request => {
// const data = request.data
//
// // Get the function we need to call in order to process the request
// const fun = functionsHash[request.type]
// if (fun === undefined) {
// logger.error('Unknown remote request type %s.', request.type)
// return
// }
//
// return fun.call(this, data, fromPod)
// })
// .catch(err => logger.error('Error managing remote videos.', err))
//
// // Don't block the other pod
// return res.type('json').status(204).end()
// }
//
// function remoteVideosQadu (req: express.Request, res: express.Response, next: express.NextFunction) {
// const requests: RemoteQaduVideoRequest[] = req.body.data
// const fromPod = res.locals.secure.pod
//
// Bluebird.each(requests, request => {
// const videoData = request.data
//
// return quickAndDirtyUpdateVideoRetryWrapper(videoData, fromPod)
// })
// .catch(err => logger.error('Error managing remote videos.', err))
//
// return res.type('json').status(204).end()
// }
//
// function remoteVideosEvents (req: express.Request, res: express.Response, next: express.NextFunction) {
// const requests: RemoteVideoEventRequest[] = req.body.data
// const fromPod = res.locals.secure.pod
//
// Bluebird.each(requests, request => {
// const eventData = request.data
//
// return processVideosEventsRetryWrapper(eventData, fromPod)
// })
// .catch(err => logger.error('Error managing remote videos.', err))
//
// return res.type('json').status(204).end()
// }
//
// async function processVideosEventsRetryWrapper (eventData: RemoteVideoEventData, fromPod: PodInstance) {
// const options = {
// arguments: [ eventData, fromPod ],
// errorMessage: 'Cannot process videos events with many retries.'
// }
//
// await retryTransactionWrapper(processVideosEvents, options)
// }
//
// async function processVideosEvents (eventData: RemoteVideoEventData, fromPod: PodInstance) {
// await db.sequelize.transaction(async t => {
// const sequelizeOptions = { transaction: t }
// const videoInstance = await fetchLocalVideoByUUID(eventData.uuid, t)
//
// let columnToUpdate
// let qaduType
//
// switch (eventData.eventType) {
// case REQUEST_VIDEO_EVENT_TYPES.VIEWS:
// columnToUpdate = 'views'
// qaduType = REQUEST_VIDEO_QADU_TYPES.VIEWS
// break
//
// case REQUEST_VIDEO_EVENT_TYPES.LIKES:
// columnToUpdate = 'likes'
// qaduType = REQUEST_VIDEO_QADU_TYPES.LIKES
// break
//
// case REQUEST_VIDEO_EVENT_TYPES.DISLIKES:
// columnToUpdate = 'dislikes'
// qaduType = REQUEST_VIDEO_QADU_TYPES.DISLIKES
// break
//
// default:
// throw new Error('Unknown video event type.')
// }
//
// const query = {}
// query[columnToUpdate] = eventData.count
//
// await videoInstance.increment(query, sequelizeOptions)
//
// const qadusParams = [
// {
// videoId: videoInstance.id,
// type: qaduType
// }
// ]
// await quickAndDirtyUpdatesVideoToFriends(qadusParams, t)
// })
//
// logger.info('Remote video event processed for video with uuid %s.', eventData.uuid)
// }
//
// async function quickAndDirtyUpdateVideoRetryWrapper (videoData: RemoteQaduVideoData, fromPod: PodInstance) {
// const options = {
// arguments: [ videoData, fromPod ],
// errorMessage: 'Cannot update quick and dirty the remote video with many retries.'
// }
//
// await retryTransactionWrapper(quickAndDirtyUpdateVideo, options)
// }
//
// async function quickAndDirtyUpdateVideo (videoData: RemoteQaduVideoData, fromPod: PodInstance) {
// let videoUUID = ''
//
// await db.sequelize.transaction(async t => {
// const videoInstance = await fetchVideoByHostAndUUID(fromPod.host, videoData.uuid, t)
// const sequelizeOptions = { transaction: t }
//
// videoUUID = videoInstance.uuid
//
// if (videoData.views) {
// videoInstance.set('views', videoData.views)
// }
//
// if (videoData.likes) {
// videoInstance.set('likes', videoData.likes)
// }
//
// if (videoData.dislikes) {
// videoInstance.set('dislikes', videoData.dislikes)
// }
//
// await videoInstance.save(sequelizeOptions)
// })
//
// logger.info('Remote video with uuid %s quick and dirty updated', videoUUID)
// }
//
// async function removeRemoteVideoRetryWrapper (videoToRemoveData: RemoteVideoRemoveData, fromPod: PodInstance) {
// const options = {
// arguments: [ videoToRemoveData, fromPod ],
// errorMessage: 'Cannot remove the remote video channel with many retries.'
// }
//
// await retryTransactionWrapper(removeRemoteVideo, options)
// }
//
// async function removeRemoteVideo (videoToRemoveData: RemoteVideoRemoveData, fromPod: PodInstance) {
// logger.debug('Removing remote video "%s".', videoToRemoveData.uuid)
//
// await db.sequelize.transaction(async t => {
// // We need the instance because we have to remove some other stuffs (thumbnail etc)
// const videoInstance = await fetchVideoByHostAndUUID(fromPod.host, videoToRemoveData.uuid, t)
// await videoInstance.destroy({ transaction: t })
// })
//
// logger.info('Remote video with uuid %s removed.', videoToRemoveData.uuid)
// }
//
// async function removeRemoteVideoAccountRetryWrapper (accountAttributesToRemove: RemoteVideoAccountRemoveData, fromPod: PodInstance) {
// const options = {
// arguments: [ accountAttributesToRemove, fromPod ],
// errorMessage: 'Cannot remove the remote video account with many retries.'
// }
//
// await retryTransactionWrapper(removeRemoteVideoAccount, options)
// }
//
// async function removeRemoteVideoAccount (accountAttributesToRemove: RemoteVideoAccountRemoveData, fromPod: PodInstance) {
// logger.debug('Removing remote video account "%s".', accountAttributesToRemove.uuid)
//
// await db.sequelize.transaction(async t => {
// const videoAccount = await db.Account.loadAccountByPodAndUUID(accountAttributesToRemove.uuid, fromPod.id, t)
// await videoAccount.destroy({ transaction: t })
// })
//
// logger.info('Remote video account with uuid %s removed.', accountAttributesToRemove.uuid)
// }
//
// async function removeRemoteVideoChannelRetryWrapper (videoChannelAttributesToRemove: RemoteVideoChannelRemoveData, fromPod: PodInstance) {
// const options = {
// arguments: [ videoChannelAttributesToRemove, fromPod ],
// errorMessage: 'Cannot remove the remote video channel with many retries.'
// }
//
// await retryTransactionWrapper(removeRemoteVideoChannel, options)
// }
//
// async function removeRemoteVideoChannel (videoChannelAttributesToRemove: RemoteVideoChannelRemoveData, fromPod: PodInstance) {
// logger.debug('Removing remote video channel "%s".', videoChannelAttributesToRemove.uuid)
//
// await db.sequelize.transaction(async t => {
// const videoChannel = await fetchVideoChannelByHostAndUUID(fromPod.host, videoChannelAttributesToRemove.uuid, t)
// await videoChannel.destroy({ transaction: t })
// })
//
// logger.info('Remote video channel with uuid %s removed.', videoChannelAttributesToRemove.uuid)
// }
//
// async function reportAbuseRemoteVideoRetryWrapper (reportData: RemoteVideoReportAbuseData, fromPod: PodInstance) {
// const options = {
// arguments: [ reportData, fromPod ],
// errorMessage: 'Cannot create remote abuse video with many retries.'
// }
//
// await retryTransactionWrapper(reportAbuseRemoteVideo, options)
// }
//
// async function reportAbuseRemoteVideo (reportData: RemoteVideoReportAbuseData, fromPod: PodInstance) {
// logger.debug('Reporting remote abuse for video %s.', reportData.videoUUID)
//
// await db.sequelize.transaction(async t => {
// const videoInstance = await fetchLocalVideoByUUID(reportData.videoUUID, t)
// const videoAbuseData = {
// reporterUsername: reportData.reporterUsername,
// reason: reportData.reportReason,
// reporterPodId: fromPod.id,
// videoId: videoInstance.id
// }
//
// await db.VideoAbuse.create(videoAbuseData)
//
// })
//
// logger.info('Remote abuse for video uuid %s created', reportData.videoUUID)
// }
//
// async function fetchLocalVideoByUUID (id: string, t: Sequelize.Transaction) {
// try {
// const video = await db.Video.loadLocalVideoByUUID(id, t)
//
// if (!video) throw new Error('Video ' + id + ' not found')
//
// return video
// } catch (err) {
// logger.error('Cannot load owned video from id.', { error: err.stack, id })
// throw err
// }
// }
//
// async function fetchVideoByHostAndUUID (podHost: string, uuid: string, t: Sequelize.Transaction) {
// try {
// const video = await db.Video.loadByHostAndUUID(podHost, uuid, t)
// if (!video) throw new Error('Video not found')
//
// return video
// } catch (err) {
// logger.error('Cannot load video from host and uuid.', { error: err.stack, podHost, uuid })
// throw err
// }
// }
