import moment from 'moment'
import { get, find, capitalize, omit } from 'lodash'

export const parseTitle = version => {
  const title = get(version, 'metadata.title')
  if (title) {
    return title.replace(/<p[^>]*>/g, '').replace(/<\/p>/g, '')
  }
  return 'Untitled'
}

export const parseAuthor = version => {
  const author = find(get(version, 'authors'), a => a.isSubmitting)
  return author ? `${author.firstName} ${author.lastName}` : 'N/A'
}

export const parseType = version => {
  const type = get(version, 'metadata.type')
  return type ? type.replace('-', ' ') : 'N/A'
}

export const parseSubmissionDate = version => {
  const submitted = get(version, 'submitted')
  const submittedDate = moment(submitted)
  const today = moment()
  const daysAgo = moment.duration(today - moment(submitted)).days()
  return submitted
    ? `${submittedDate.format('DD.MM.YYYY')} ${
        daysAgo > 0 ? `(${daysAgo} days)` : ''
      }`
    : 'N/A'
}

export const mapStatusToLabel = ({ visibleStatus, status }) => {
  if (visibleStatus) {
    return visibleStatus
  } else if (status) {
    return capitalize(status)
  }
  return 'Draft'
}

export const parseVersion = version => ({
  author: parseAuthor(version),
  title: parseTitle(version),
  submitted: parseSubmissionDate(version),
  type: parseType(version),
  abstract: get(version, 'metadata.abstract'),
  version: get(version, 'version'),
})

export const parseJournalIssue = (journal, metadata) =>
  journal.issueTypes.find(t => t.value === get(metadata, 'issue'))

export const parseSearchParams = url => {
  const params = new URLSearchParams(url)
  const parsedObject = {}
  /* eslint-disable */
  for ([key, value] of params) {
    parsedObject[key] = value
  }
  /* eslint-enable */
  return parsedObject
}

export const parseVersionOptions = fragments =>
  fragments.map(f => ({
    value: f.id,
    label: `Version ${f.version} - updated on ${moment(f.submitted).format(
      'DD.MM.YYYY',
    )}`,
  }))

const alreadyAnswered = `You have already answered this invitation.`
export const redirectToError = redirectFn => err => {
  const errorText = get(JSON.parse(err.response), 'error')
  if (errorText.includes('has already been answered')) {
    redirectFn('/error-page', alreadyAnswered)
  } else {
    redirectFn('/error-page', 'Oops! Something went wrong.')
  }
}

export const parseReviewResponseToForm = (review = {}) => {
  const comments = review.comments || []
  const publicComment = comments.find(c => c.public)
  const privateComment = comments.find(c => !c.public)
  return {
    ...review,
    public: get(publicComment, 'content'),
    files: get(publicComment, 'files'),
    confidential: get(privateComment, 'content'),
    hasConfidential: !!get(privateComment, 'content'),
  }
}

export const parseReviewRequest = (review = {}) => {
  const comments = [
    {
      public: true,
      content: review.public,
      files: review.files || [],
    },
  ]

  if (review.hasConfidential) {
    comments.push({
      public: false,
      content: review.confidential,
      files: [],
    })
  }
  return {
    ...omit(review, ['public', 'confidential', 'hasConfidential', 'files']),
    comments,
  }
}