/* eslint-disable no-console */
import winston from 'winston'
import chalk from 'chalk'

import { LoggerLevels, ELoggerLevel } from './constants'
import { currentLogLevel } from './log-level'
export * from './constants'
export * from './log-level'

type logFun = (content: string) => void

const logLevelValue = (logLevel: ELoggerLevel) => {
  return LoggerLevels[logLevel]
}

const shouldOutput = (logLevel: ELoggerLevel): boolean => {
  const currentLogLevelValue = logLevelValue(currentLogLevel())
  const messageLogLevelValue = logLevelValue(logLevel)
  return messageLogLevelValue <= currentLogLevelValue
}

const outputWhereAppropriate = (
  logLevel: ELoggerLevel,
  logger: winston.LeveledLogMethod,
  message: string,
) => {
  if (shouldOutput(logLevel)) {
    logger(message)
  }
}

const logger = winston.createLogger({
  level: ELoggerLevel.debug,
  levels: LoggerLevels,
  transports: new winston.transports.Console({
    log(info, next) {
      console.log(info.message)
      next()
    },
  }),
})

const newline = () => {
  console.log()
}

const error = (content: unknown, tryMessage?: string) => {
  if (!(content instanceof Error) || !content.message) {
    return
  }
  let outputString = ''
  const message = content.message
  const padding = '    '
  const header = chalk.redBright(
    `\n━━━━━━ Error ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`,
  )
  const footer = chalk.redBright(
    '\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n',
  )
  outputString += header
  const lines = message.split('\n')
  for (const line of lines) {
    outputString += `${padding}${line}\n`
  }

  if (tryMessage) {
    outputString += `\n${padding}${chalk.bold('What to try:')}\n`
    const lines = tryMessage.split('\n')
    for (const line of lines) {
      outputString += `${padding}${line}\n`
    }
  }

  outputString += footer

  outputWhereAppropriate(ELoggerLevel.error, logger.error, outputString)
}

const warn: logFun = (content) => {
  const message = chalk.yellow(content)
  outputWhereAppropriate(ELoggerLevel.warning, logger.warning, message)
}

const success: logFun = (content) => {
  const message = chalk.bold(`✅ Success! ${chalk.green(content)}.`)
  outputWhereAppropriate(ELoggerLevel.info, logger.info, message)
}

const completed: logFun = (content) => {
  const message = `${chalk.green('✔')} ${content}`
  outputWhereAppropriate(ELoggerLevel.info, logger.info, message)
}

const info: logFun = (content) => {
  const message = content
  outputWhereAppropriate(ELoggerLevel.info, logger.info, message)
}

const debug: logFun = (content) => {
  const message = chalk.gray(content)
  outputWhereAppropriate(ELoggerLevel.debug, logger.debug, message)
}

const output = {
  newline,
  error,
  warn,
  success,
  completed,
  info,
  debug,
}

export default output