package com.proceranetworks.deployer

import pl._

import scala.annotation.tailrec
import java.io._

import net.lag.configgy._
import st.salanki.libsalank.Logged

private abstract class TreeItem
private case class TreeFolder(name: String, items: List[TreeItem]) extends TreeItem
private case class TreeLeaf[A](item: A) extends TreeItem

private case class SystemTree(systems: List[SystemActor]) {
  protected val treeComponents = for (system <- systems) yield system.groups.foldLeft[TreeItem](TreeLeaf(system))((in, item) => TreeFolder(item, List(in)))

  private def filterInTree(tree: List[TreeItem], node: TreeFolder): List[TreeFolder] = {
    tree.filter(item => {
      item match {
        case x: TreeFolder if (x.name == node.name) => true
        case _ => false
      }
    }).asInstanceOf[List[TreeFolder]]
  }
  private def filterNotInTree(tree: List[TreeItem], node: TreeFolder) = {
    tree.filterNot(item => {
      item match {
        case x: TreeFolder if (x.name == node.name) => true
        case _ => false
      }
    })
  }

  private def collapseTree(tree: List[TreeItem], merged: List[TreeItem]): List[TreeItem] = {
    tree match {
      case Nil => for (node <- merged) yield node match {
        case x: TreeFolder => TreeFolder(x.name, collapseTree(x.items, Nil))
        case x: TreeLeaf[_] => x
      }
      case head :: tail => head match {
        case x: TreeFolder => collapseTree(filterNotInTree(tree, x), TreeFolder(x.name, filterInTree(tree, x).map(_.items).flatten) :: merged)
        case x: TreeLeaf[_] => collapseTree(tail, head :: merged)
      }
    }
  }
  val asList = collapseTree(treeComponents, Nil)
}

object Generator {
  /* Using the existing systems map and re-arranging it in a tree */
  private val systems = deployerMain.markets.map(_._2).flatten.toList.distinct
  private val systemTree = SystemTree(systems).asList

  private def preFilter(s: SystemActor) = try {
    s.pl.model.archType != ArchTypes.PSM && s.pl.model.archType != ArchTypes.PLS
    } catch {
      case e: Exception => false
    }


  /**
   * Generate PacketLogic client systems file
   */
  def generatePsx(mole: Boolean, filterSystems: Boolean = false) = {
    /* This part is really ugly. It is for removing the "All" folder by first filtering the systemTree for the "All" folder, then finding the "All" folder in it again to add all the items in it to the tree root */
    val patchedSystemTree = systemTree.filterNot(item => {
      item match {
        case x: TreeFolder if (x.name.compareToIgnoreCase("all") == 0) => true
        case _ => false
      }
    }) ::: systemTree.find(item => {
      item match {
        case x: TreeFolder if (x.name.compareToIgnoreCase("all") == 0) => true
        case _ => false
      }
    }).map(case x:TreeFolder => x.items).getOrElse(List[TreeFolder]()) // Do I need {} here?


    def systemEntry(system: SystemActor, moleIp: Boolean, customName: Option[String] = None, syncedSystems: List[SystemActor] = Nil) = {
          val password = system.userMap.get("admin").map(_.clearTextPassword.get).getOrElse("pldemo00")
          val ip = moleIp match {
            case true => system.moleIp
            case false => system.ip
          }
          val name = customName.getOrElse(system.name)
          val syncedsystems = syncedSystems.map(system => moleIp match {
            case true => system.moleIp
            case false => system.ip
          }).mkString(",")

          <system password={ password } defaultview="Surveillance" differentpasswords="0" useproxy="0" username="admin" autoconnect="0" address={ ip } usecompression="1" syncedsystems={syncedsystems} name={ name }/>
        }

    def walkTree(tree: List[TreeItem], moleIp: Boolean, atRoot: Boolean = true): xml.NodeSeq = {
      val items = for (node <- tree) yield node match {
        case node: TreeFolder => <folder name={ node.name }>{ walkTree(node.items, moleIp, false) }</folder>
        case TreeLeaf(systema) => {
          systemEntry(systema.asInstanceOf[SystemActor], moleIp)
        }
      }

      val allSystems: List[SystemActor] = tree.filter(_ match {case _: TreeLeaf[_] => true case _ => false}).asInstanceOf[List[TreeLeaf[SystemActor]]].map(_.item).filter(s => (filterSystems && preFilter(s)) || (!filterSystems))
      allSystems.reverse match {
        case head :: tail if(tail.size > 0) => systemEntry(head, moleIp, Some("All Systems"), tail) :: items
        case _ if atRoot == true => {if(filterSystems) systems.filter(s => preFilter(s)) else systems } match {
          case head :: tail if(tail.size > 0) => systemEntry(head, moleIp, Some("All Systems"), tail) :: items
          case _ => items
        }
        case _ => items
      }
    }

    val folderName = if (deployerMain.marketFile == "markets.conf") "Deployer" else deployerMain.marketFile.split("/").last.replace("markets.", "").replace(".conf", "")

    val content =
      <Systems>
        <folder name={ folderName }>
          { if(mole) <folder name="Direct"> {walkTree(patchedSystemTree, false)}</folder>
          else walkTree(patchedSystemTree, false) }
          { if(mole) <folder name="SSH Forwarded"> {walkTree(patchedSystemTree, true)}</folder>}
        </folder>
      </Systems>

    val fileName = "psx/" + folderName + ".psx"
    val fos = new DataOutputStream(new FileOutputStream(new File(fileName)))
    fos writeBytes "<!DOCTYPE plclient-systemmanager-export>\n"
    fos writeBytes content.toString
    fos close

    fileName
  }

  /** Generates forward section of mole configs */
  def generateMole() = {
    val forwards = for (system <- systems) yield {
      def forward(port: Int) = system.moleIp+":"+{if(port == 22) 42002 else port} +"="+system.ip+":"+port
      "[forwards."+system.name+"]" :: forward(42000) :: forward(42001) :: forward(system.configMap.getInt("ssh_port",42002)) :: forward(8443) :: "" :: Nil
    }

    if(systems.size*4 > 250) println("Warning: A lot of systems are being forwarded in this mole configuration. You will need to increase the number of file descriptors by doing: 'ulimit -n " + (systems.size*4+100) + "' before you run mole")
    val data = "; Autogenerated forwards by Deployer from: "+deployerMain.marketFile.split("/").last+ "\n\n" + forwards.flatten.mkString("\n")

    val fos = new DataOutputStream(new FileOutputStream(new File("mole-generated.ini")))
    fos writeBytes data
    fos close

    "mole-generated.ini"
  }
}