src/main/scala/li/cil/oc/integration/jei/CallbackDocHandler.scala

package li.cil.oc.integration.jei

import java.util
import javax.annotation.Nonnull

import _root_.net.minecraft.client.Minecraft
import _root_.net.minecraft.item.ItemStack
import _root_.net.minecraft.util.EnumChatFormatting
import com.google.common.base.Strings
import li.cil.oc.api
import li.cil.oc.api.driver.EnvironmentAware
import li.cil.oc.api.prefab.DriverTileEntity
import li.cil.oc.server.driver.Registry
import li.cil.oc.server.machine.Callbacks
import mezz.jei.api.gui.IDrawable
import mezz.jei.api.gui.IRecipeLayout
import mezz.jei.api.recipe.BlankRecipeCategory
import mezz.jei.api.recipe.BlankRecipeWrapper
import mezz.jei.api.recipe.IRecipeHandler
import mezz.jei.api.recipe.IRecipeWrapper

import scala.collection.convert.WrapAsJava._
import scala.collection.convert.WrapAsScala._
import scala.collection.mutable

object CallbackDocHandler {

  import mezz.jei.api.IModRegistry

  private val DocPattern = """(?s)^function(\(.*?\).*?) -- (.*)$""".r

  private val VexPattern = """(?s)^function(\(.*?\).*?); (.*)$""".r

  def getRecipes(registry: IModRegistry): util.List[_] = registry.getItemRegistry.getItemList.collect {
    case stack: ItemStack =>
      val callbacks = getCallbacks(api.Driver.environmentFor(stack)).toBuffer

      // TODO remove in OC 1.7
      if (callbacks.isEmpty) {
        callbacks ++= (Option(Registry.driverFor(stack)) match {
          case Some(driver: EnvironmentAware) =>
            getCallbacks(driver.providedEnvironment(stack))
          case _ => Registry.blocks.collect {
            case driver: DriverTileEntity with EnvironmentAware =>
              if (driver.getTileEntityClass != null && !driver.getTileEntityClass.isInterface)
                driver.providedEnvironment(stack)
              else null
            case driver: EnvironmentAware => driver.providedEnvironment(stack)
          }.filter(_ != null).flatMap(getCallbacks)
        })
      }

      if (callbacks.nonEmpty) {
        val pages: mutable.Buffer[String] = mutable.Buffer.empty[String]
        pages += callbacks.toArray.sorted.foldLeft("") {
          (last, doc) =>
            if (last.lines.length + 2 + doc.lines.length > 12) {
              // We've potentially got some pretty long documentation here, split it up first
              val split = last.lines.grouped(12).map(_.mkString("\n")).toArray
              split.foreach(pages += _)
              doc
            }
            else if (last.nonEmpty) last + "\n\n" + doc
            else doc
        }
        Option(pages.map(page => new CallbackDocRecipe(stack, page)))
      }
      else None
  }.collect {
    case Some(handler) => handler
  }.flatten.toList

  private def getCallbacks(env: Class[_]) = if (env != null) {

    Callbacks.fromClass(env).map {
      case (name, callback) =>
        val doc = callback.annotation.doc
        if (Strings.isNullOrEmpty(doc)) name
        else {
          val (signature, documentation) = doc match {
            case DocPattern(head, tail) => (name + head, tail)
            case VexPattern(head, tail) => (name + head, tail)
            case _ => (name, doc)
          }
          wrap(signature, 160).map(EnumChatFormatting.BLACK.toString + _).mkString("\n") +
            EnumChatFormatting.RESET + "\n" +
            wrap(documentation, 152).map("  " + _).mkString("\n")
        }
    }
  }
  else Seq.empty

  protected def wrap(line: String, width: Int) = Minecraft.getMinecraft.fontRendererObj.listFormattedStringToWidth(line, width)

  object CallbackDocRecipeHandler extends IRecipeHandler[CallbackDocRecipe] {

    override def getRecipeWrapper(recipe: CallbackDocRecipe) = recipe

    override def getRecipeCategoryUid = CallbackDocRecipeCategory.getUid

    override def isRecipeValid(recipe: CallbackDocRecipe) = true

    override def getRecipeClass = classOf[CallbackDocRecipe]
  }

  class CallbackDocRecipe(val stack: ItemStack, val page: String) extends BlankRecipeWrapper {

    override def getInputs: util.List[_] = List(stack)

    override def drawInfo(@Nonnull minecraft: Minecraft, recipeWidth: Int, recipeHeight: Int, mouseX: Int, mouseY: Int): Unit = {
      for ((text, line) <- page.lines.zipWithIndex) {
        minecraft.fontRendererObj.drawString(text, 4, 4 + line * (minecraft.fontRendererObj.FONT_HEIGHT + 1), 0x333333, false)
      }
    }
  }

  object CallbackDocRecipeCategory extends BlankRecipeCategory {

    import mezz.jei.api.IGuiHelper

    val recipeWidth: Int = 160
    val recipeHeight: Int = 125
    private var background: IDrawable = null

    def initialize(guiHelper: IGuiHelper) {
      background = guiHelper.createBlankDrawable(recipeWidth, recipeHeight)
    }

    override def getBackground: IDrawable = background

    override def setRecipe(recipeLayout: IRecipeLayout, recipeWrapper: IRecipeWrapper) {

    }

    override def getTitle = "OpenComputers API"

    override def getUid = "oc.api"
  }

}