//设置package包名称以及导入依赖的类
package com.karasiq.torrentstream.frontend

import com.karasiq.bootstrap.BootstrapImplicits._
import com.karasiq.bootstrap.grid.GridSystem
import com.karasiq.bootstrap.icons.FontAwesome
import com.karasiq.bootstrap.navbar.{NavigationBar, NavigationTab}
import com.karasiq.torrentstream.frontend.components.TorrentManagementPanel
import org.scalajs.dom
import org.scalajs.jquery.jQuery
import rx._

import scala.scalajs.js.JSApp
import scala.scalajs.js.annotation.JSExport
import scalatags.JsDom.all._

@JSExport
object TorrentStreamFrontend extends JSApp {
  private implicit val context = implicitly[Ctx.Owner]

  @JSExport
  override def main(): Unit = {
    jQuery(() ? {
      val navigationBar = NavigationBar(
        NavigationTab("Torrents", "torrents", "file".fontAwesome(FontAwesome.fixedWidth), new TorrentManagementPanel)
      )
      val body = dom.document.body
      body.appendChild(navigationBar.navbar("TorrentStream").render)
      body.appendChild {
        GridSystem.container(id := "main-container")(
          GridSystem.mkRow(navigationBar.content)
        ).render
      }
    })
  }
} 

//设置package包名称以及导入依赖的类
import scala.scalajs.js.JSApp
import org.scalajs.dom
import xyz.ariwaranosai.tidori.dom.DomElements._
import xyz.ariwaranosai.tidori.dom.OperatorContext

import scalatags.JsDom.all._
import xyz.ariwaranosai.tidori.dom.DomOperator._
import xyz.ariwaranosai.tidori.dom.BeatOperatorImplicit._



object Example extends JSApp {
  @scala.scalajs.js.annotation.JSExport
  override def main(): Unit = {
    println("hello world!")
    val pNode = dom.document.getElementById("broad")
    val c = OperatorContext(pNode, 200)

    val twitter = a(href:="https://twitter.com/ariwaranosai").render.bbs("twitter")
    val blog = a(href:="http://ariwaranosai.xyz").render.bbs("blog")

    val title = "????-???? ? ?? ".bb ~: htmlBR.b ~:
      " ??????,???????,?????? ".bb ~: htmlBR.b ~:
      " ????,?????,????".bb ~: 4.del() ~: 1.delay ~:
      speed(4) ~: "???".bb ~: speed(0.25) ~: ",???? ".bb ~: htmlBR.b ~:
      " ????? ????? ?????? ".bb ~: htmlBR.b ~:
      " vim? ??? ???? ?3ds??? ".bb ~: htmlBR.b ~:
      " ?haskell????,????Scala??,?????Python ".bb ~: htmlBR.b ~:
      " C++????????,????????? ".bb ~: htmlBR.b ~:
      " ????????,?????? ".bb ~: htmlBR.b ~:
      " OSX Fedora Arch Win HHKB ".bb ~: htmlBR.b ~:
      " ?????,??????????? ".bb ~: htmlBR.b ~:
      " ??: ".bb ~: twitter ~: " ".bb ~: blog

    title.run(c)
  }
} 

//设置package包名称以及导入依赖的类
package net.xylophones.frogger

import org.scalajs.dom
import org.scalajs.dom.document
import org.scalajs.dom.html.{Canvas}

import scala.scalajs.js.JSApp
import scala.scalajs.js.timers._

object App extends JSApp {
  private val canvas = document.getElementById("frogger").asInstanceOf[Canvas]
  val ctx = canvas.getContext("2d").asInstanceOf[dom.CanvasRenderingContext2D]
  private val mediaPath = canvas.getAttribute("mediaPath")
  private val soundPlayer = new SoundPlayer(mediaPath)

  def main(): Unit = {
    addCanvas()
    val m = Layers.initialModel()
    loop(model = m)
  }

  def loop(lastTime: Long = System.currentTimeMillis, model: Model): Unit = {
    draw(model)

    val interval: Long = System.currentTimeMillis() - lastTime
    val desiredPause = 1000 / 25
    val pause = Math.max(0, desiredPause - interval)

    setTimeout(pause) {
      val newModel: Model = updateModel(model)

      loop(System.currentTimeMillis(), newModel)
    }
  }

  private def updateModel(model: Model): Model = {
    val newModel = ModelUpdaters.updaters.foldLeft(model) {
      (updatedModel: Model, updater: ModelUpdater) => updater.updateIfApplicable(updatedModel)
    }

    for (s <- newModel.sounds) {soundPlayer.play(s)}

    newModel.copy(sounds = Seq())
  }

  def draw(model: Model) = {
    (model.layers.all zip model.positions).foreach { case (l, p) => l.draw(ctx, p, model) }

    model.layers.frogLayer.draw(ctx, model.frogPosition, model)
  }

  def addCanvas(): Unit = {
    canvas.width = Config.gameWidth
    canvas.height = Config.gameHeight
  }
} 

//设置package包名称以及导入依赖的类
package org.codeape.sc.frontend

import io.udash._
import io.udash.wrappers.jquery._
import org.codeape.sc.shared.MainServerREST
import org.scalajs.dom
import org.scalajs.dom.{Element, document}

import scala.scalajs.js.JSApp
import scala.scalajs.js.annotation.JSExport
import scala.util.Try

object Context {
  implicit val executionContext = scalajs.concurrent.JSExecutionContext.Implicits.queue
  private val routingRegistry = new RoutingRegistryDef
  private val viewPresenterRegistry = new StatesToViewPresenterDef

  implicit val applicationInstance = new Application[RoutingState](routingRegistry, viewPresenterRegistry, RootState)

  import io.udash.rest._
  val port = Try(dom.window.location.port.toInt).getOrElse(80)
  val host = dom.window.location.hostname
  val restServer = DefaultServerREST[MainServerREST](host, port, "/api/")
}

object Init extends JSApp with StrictLogging {
  import Context._

  @JSExport
  override def main(): Unit = {
    logger.info("StampClock started")
    jQ(document).ready((_: Element) => {
      val appRoot = jQ("#application").get(0)
      if (appRoot.isEmpty) {
        logger.error("Application root element not found! Check your index.html file!")
      } else {
        applicationInstance.run(appRoot.get)
      }
    })
  }
} 

//设置package包名称以及导入依赖的类
package formulate

import formulate.react._
import japgolly.scalajs.react._
import japgolly.scalajs.react.vdom.prefix_<^._
import monocle._
import org.scalajs.dom
import scala.scalajs.js.JSApp

object Main extends JSApp {
  val form: Form =
    GroupForm((1 to 100).map(i => TextField(s"Item $i")).toList)

  val Main = ReactComponentB[Unit]("FormBuilder example")
    .initialState(form)
    .render { proxy =>
      <.table(
        <.tbody(
          <.tr(
            <.td(FormRenderer.Default(proxy)),
            <.td(FormRenderer.ReadOnly(proxy))
          )
        )
      )
    }
    .build

  def main(): Unit =
    ReactDOM.render(Main(), dom.document.getElementById("app"))
} 

//设置package包名称以及导入依赖的类
package com.outr.nextui.examples.browser

import com.outr.nextui.browser.ScalaJS
import com.outr.nextui.examples.Examples
import org.scalajs.dom.{Event, document, html}

import scala.scalajs.js.JSApp

object ScalaJSExamples extends JSApp {
  override def main(): Unit = {
    val div = document.createElement("div").asInstanceOf[html.Div]
    Examples().foreach { ui =>
      val a = document.createElement("a").asInstanceOf[html.Anchor]
      a.href = "#"
      a.addEventListener("click", {(evt: Event) =>
        document.body.removeChild(div)
        ScalaJS(ui)
      }, true)
      a.textContent = ui.name
      val p = document.createElement("p").asInstanceOf[html.Paragraph]
      p.appendChild(a)
      div.appendChild(p)
    }
    document.body.appendChild(div)
  }
} 

//设置package包名称以及导入依赖的类
package tutorial.webapp

import scala.scalajs.js.JSApp
import scala.scalajs.js
import js.DynamicImplicits._
import js.Dynamic.{global => g}

object TutorialApp extends JSApp {
  val five = g.require("johnny-five")

  def main(): Unit = {
    five.Board().on("ready", () => {
      println("Board ready")
      val led = five.Led(13)
      led.blink(500)
    })
  }
} 

//设置package包名称以及导入依赖的类
package com.oni.udash

import acyclic.file

import io.udash._
import io.udash.wrappers.jquery._
import org.scalajs.dom.{ Element, document }

import scala.scalajs.js.JSApp
import scala.scalajs.js.annotation.JSExport
import scalacss.Defaults._
import scalacss.ScalatagsCss._
import scalatags.JsDom._
import com.oni.udash.styles._
import com.oni.udash.styles.OniStyles2
import com.oni.udash.styles.GlobalStyles
import com.oni.udash.styles.DemoStyles
import com.oni.udash.styles.partials.FooterStyles
import com.oni.udash.styles.partials.HeaderStyles
import org.scalajs.dom.raw.HTMLStyleElement

object Init extends JSApp with StrictLogging {
  import Context._

  @JSExport
  override def main(): Unit = {
    jQ(document).ready((_: Element) => {
      val appRoot = jQ("#application").get(0)
      if (appRoot.isEmpty) {
        logger.error("Application root element not found! Check your index.html file!")
      } else {
        applicationInstance.run(appRoot.get)

        jQ(GlobalStyles.render[TypedTag[HTMLStyleElement]].render).insertBefore(appRoot.get)
        jQ(DemoStyles.render[TypedTag[HTMLStyleElement]].render).insertBefore(appRoot.get)
        jQ(OniStyles.render[TypedTag[HTMLStyleElement]].render).insertBefore(appRoot.get)
        jQ(OniStyles2.render[TypedTag[HTMLStyleElement]].render).insertBefore(appRoot.get)
        jQ(CsStyles.render[TypedTag[HTMLStyleElement]].render).insertBefore(appRoot.get)
        jQ(CsStyles2.render[TypedTag[HTMLStyleElement]].render).insertBefore(appRoot.get)
        jQ(FooterStyles.render[TypedTag[HTMLStyleElement]].render).insertBefore(appRoot.get)
        jQ(HeaderStyles.render[TypedTag[HTMLStyleElement]].render).insertBefore(appRoot.get)
      }
    })
  }
} 

//设置package包名称以及导入依赖的类
package diversion.substrate

import java.lang.Math._

import org.scalajs.dom
import org.scalajs.dom.CanvasRenderingContext2D
import org.scalajs.dom.html.Canvas

import scala.scalajs.js
import scala.scalajs.js.JSApp
import scala.scalajs.js.annotation.JSExport

object SubstrateApp extends JSApp {

  @JSExport
  override def main(): Unit = {}

  @JSExport
  def start(canvasName: String): Unit = {
    val canvas = dom.document.getElementById(canvasName).asInstanceOf[Canvas]
    val ctx = canvas.getContext("2d").asInstanceOf[CanvasRenderingContext2D]

    def h = canvas.height

    def w = canvas.width

    clear(canvas)

    var x = 0.0
    type Graph = (String, Double => Double)

    val graphs = Seq[Graph](
      ("red", sin),
      ("green", x => abs(x % 4 - 2) - 1),
      ("blue", x => sin(x / 12) * sin(x))
    ).zipWithIndex

    js.timers.setInterval(20) {
      x = (x + 1) % w
      if (x == 0) {
        clear(canvas)
      }

      for (((color, f), i) <- graphs) {
        val offset = h / 3 * (i + 0.5)
        val y = f(x / w * 75) * h / 30

        ctx.fillStyle = color
        ctx.fillRect(x, y + offset, 3, 3)
      }
    }
  }

  def clear(canvas: Canvas): Unit = {
    canvas.width = canvas.clientWidth
    canvas.height = canvas.clientHeight
  }


} 

//设置package包名称以及导入依赖的类
package org.pragmas.OxShow

import macrocompat.bundle
import scala.scalajs.js.JSApp
import scala.scalajs.js.annotation._
import org.scalajs.dom.raw.HTMLElement
import org.scalajs.dom
import scalatags.JsDom.all._

object Paths {
  val origin = dom.window.location.origin
  val public = s"${origin}/public"
  val defs = s"${public}/defs"
}

object MainApp extends JSApp {

  var container: HTMLElement = _

  def preparePage(defJson: String): Unit = {
    val ddp = new DocumentDefinitionParser(defJson)
    val dp = new DocumentProducer(ddp.doc)
    val dpc = div(cls:="document-producer-container").render    
    this.container.appendChild(dpc)
    dp.pageContent(dpc)
  }

  @JSExport
  def load(id: String, document: String) = {
    this.container = dom.document.getElementById(id).asInstanceOf[HTMLElement]
    preparePage(document)
  }

  def main() : Unit = {
  }

} 

//设置package包名称以及导入依赖的类
package jp.ne.opt.client

import jp.ne.opt.domain.TodoStore

import scala.scalajs.js.JSApp
import scala.scalajs.js.annotation.JSExport
import japgolly.scalajs.react.{ReactComponentB, ReactDOM}
import japgolly.scalajs.react.vdom.prefix_<^._
import org.scalajs.dom.document

object TutorialApp extends JSApp {
  def main(): Unit = {
    println("helloWorld")
  }

  @JSExport
  def count():Unit = {
    countNumber +=1
    println(countNumber)
  }
  var countNumber: Int = 1

  val Hello =
    ReactComponentB[String]("Hello")
      .render_P(name => <.div(^.id:="hoge","Hello there ", name))
      .build

  ReactDOM.render(Hello("hohohohoho"), document.getElementById("content"))
} 

//设置package包名称以及导入依赖的类
package scalatags.hokko

import hokko.core.{DBehavior, Engine}
import org.scalajs.dom

import scala.scalajs.js.JSApp

trait HokkoDomApp extends JSApp {
  lazy val htmldsl   = scalatags.Hokko.all
  lazy val extraHtml = scalatags.Hokko.tags2

  type Html = htmldsl.Tag

  def initialize(): dom.Element = {
    val engine     = Engine.compile(ui, ui.changes)
    val domPatcher = new DomPatcher(ui.init.render(engine))

    engine.subscribeForPulses { pulses =>
      pulses(ui.changes).foreach { tag =>
        val newVDom = tag.render(engine)
        domPatcher.applyNewState(newVDom)
      }
    }

    domPatcher.renderedElement
  }

  def main(): Unit = {
    println("Starting App")

    def start(): Unit = {
      val element = this.initialize()
      this.container.appendChild(element)
      ()
    }

    if (dom.document.readyState != "loading") start()
    else
      dom.document
        .addEventListener("DOMContentLoaded", (_: dom.Event) => start())
  }

  def container: dom.Element = dom.document.body
  def ui: DBehavior[Html]
} 

//设置package包名称以及导入依赖的类
package app

import scala.scalajs.js.annotation.JSExport
import org.scalajs.dom
import japgolly.scalajs.react.ReactDOM
import scala.scalajs.js.JSApp
import japgolly.scalajs.react.ReactComponentB
import css.StyleStore.MyStyles
import scalacss.Defaults._
import scalacss.ScalaCssReact._
import scalacss.internal.mutable.GlobalRegistry


@JSExport
object App extends JSApp {

  private val component = ReactComponentB[Unit]("App")
    .render(_ => AppRouter.component())
    .build

  @JSExport
  def main(): Unit = {
    println("-----> in App AdminUser -------")
    MyStyles.addToDocument()
    GlobalRegistry.addToDocumentOnRegistration()
    ReactDOM.render(component(), dom.document.getElementById("mainRootBody"))
  }

} 

//设置package包名称以及导入依赖的类
package chartjs

import chartjs.chart.{DataSet, Line}

import scala.scalajs.js.JSApp
import scala.scalajs.js.annotation.JSExport


object App extends JSApp {
  def main(): Unit = {
    chart()
  }

  @JSExport
  def chart(): Any = {
    val tsc = TimeSeriesChart("chart", Line)
    tsc.appendDataSet("TTEst")
    tsc.append(1, 1)
    tsc.append(2, 2)
    tsc.append(3, 3)
    tsc.append(4, 3)
  }
} 

//设置package包名称以及导入依赖的类
package se.ta

import scala.concurrent.duration._
import scala.scalajs.js.JSApp

import japgolly.scalajs.react._
import japgolly.scalajs.react.vdom.prefix_<^._
import monix.execution.Scheduler.Implicits.global
import monix.reactive.Observable
import org.scalajs.dom.document

object SampleApp1 extends JSApp {

  def viewTick(tick: Long) =
    <.div(
      <.p(s"Tick: $tick seconds")
    )

  val Tick =
    ReactComponentB[Long]("Tick")
      .render_P(tick => viewTick(tick))
      .build

  def main(): Unit = {

    println("Starting counting  10 ticks")

    Observable.interval(1 second)
      .doOnNext(x => ReactDOM.render(Tick(x), document.body))
      .take(10)
      .dump("0")
      .subscribe()
  }
} 

//设置package包名称以及导入依赖的类
package eldis.redux.examples.japgolly

import scala.scalajs.js
import js.annotation._
import scala.scalajs.js.JSApp
import japgolly.scalajs.react._
import org.scalajs.dom

object Main extends JSApp {

  
  private object Dependencies {

    @JSImport("react", JSImport.Namespace)
    @js.native
    object React extends js.Object {}

    @JSImport("react-dom", JSImport.Namespace)
    @js.native
    object ReactDOM extends js.Object {}

    def setup = {
      js.Dynamic.global.React = React
      js.Dynamic.global.ReactDOM = ReactDOM
    }
  }

  def main(): Unit = {
    Dependencies.setup

    ReactDOM.render(
      App(
        Store(
          Seq(
            "Red Hat",
            "Canonical",
            "Apple",
            "Microsoft"
          )
        )
      ),
      dom.document.getElementById("root")
    )
  }

} 

//设置package包名称以及导入依赖的类
package eldis.redux.examples.react

import scala.scalajs.js
import js.annotation._
import scala.scalajs.js.JSApp
import eldis.react._
import org.scalajs.dom

object Main extends JSApp {

  def main(): Unit = {
    ReactDOM.render(
      App(
        Store(
          Seq(
            "Red Hat",
            "Canonical",
            "Apple",
            "Microsoft"
          )
        )
      ),
      dom.document.getElementById("root")
    )
  }

} 

//设置package包名称以及导入依赖的类
package com.github.aafa.vending

import com.github.aafa.vending.diode._
import org.scalajs.dom.{Node, document}

import scala.scalajs.js.JSApp
import scalatags.JsDom.all._

object Main extends JSApp {
  AppCircuit.subscribe(AppCircuit.zoom(a => a))(_ => render())

  def main(): Unit = {
    render()
  }

  private def render() = {
    document.body.innerHTML = ""
    content(document.body)
  }

  def content(targetNode: Node): Unit = {
    val insertCoin = button(`class` := "insertCoin", onclick := { () => AppCircuit(InsertCoin(CandyCoin(1))) }, ">> Insert CandyCoin here <<")
    val candies = AppCircuit.zoom(_.listOfCandies).value
    val coinsSlot = AppCircuit.zoom(_.coinsSlot).value.value
    val getTheCandy = AppCircuit.zoom(_.getTheCandySlot).value.map(_.name)
    val info = AppCircuit.zoom(_.machineInfo).value

    targetNode.appendChild(
      div(`class` := "container",
        h2("Candies for everyone!"),
        div(info),
        div(insertCoin),
        div(coinsSlot + " coins"),
        ul(`class` := "candyList",
          candies map (c => div(
            button(`class` := "candy", onclick := { () => AppCircuit(PurchaseCandy(c.candy)) },
              s"Purchase ${c.candy.name} for ${c.price.value}cc, only ${c.quantity} left")))
        ),
        div(`class` := "footer",
          button(
            `class` := "get-candy-slot", onclick := { () => AppCircuit(CandyTakenFromSlot) },
            getTheCandy
          )
        )
      ).render
    )

  }
} 

//设置package包名称以及导入依赖的类
package se.lu.nateko.cp.doi.gui

import scala.scalajs.js.JSApp
import org.scalajs.dom.document
import se.lu.nateko.cp.doi.gui.views.MainView

object DoiApp extends JSApp {

	val initState = DoiState(
		prefix = "10.5072",//test value; the actual one is fetched from backend
		dois = Nil,
		info = Map.empty,
		selected = None,
		ioState = IoState(None, None),
		alreadyExists = None,
		error = None
	)
	val store = new DoiRedux.Store(DoiReducer.reducer, initState)

	val mainView = new MainView(store)
	val renderer = new Renderer(mainView)
	store.subscribe(renderer)

	def main(): Unit = {
		val mainDiv = document.getElementById("main")
		mainDiv.parentNode.replaceChild(mainView.element.render, mainDiv)

		store.dispatch(ThunkActions.FetchDoiPrefix)
		store.dispatch(ThunkActions.DoiListRefreshRequest)
	}

} 

//设置package包名称以及导入依赖的类
package weatherApp

import org.scalajs.dom
import scala.scalajs.js.{JSApp}
import scalajs.js
import scalajs.js.annotation._
import japgolly.scalajs.react.WebpackRequire
import japgolly.scalajs.react.vdom.html_<^._

import weatherApp.router.{AppRouter}

object Main extends JSApp {
  @JSImport("normalize.css", JSImport.Namespace)
  @js.native
  object Normalize extends js.Any


  @JSImport("../../assets/scss/main.scss", JSImport.Namespace)
  @js.native
  object CSS extends js.Any

  @JSImport("weather-icons/css/weather-icons.min.css", JSImport.Namespace)
  @js.native
  object WeatherIcons extends js.Any

  @JSImport("weather-icons/css/weather-icons-wind.min.css", JSImport.Namespace)
  @js.native
  object WeatherIconsWind extends js.Any

  def require(): Unit = {
    WebpackRequire.React
    WebpackRequire.ReactDOM
    Normalize
    CSS
    WeatherIcons
    WeatherIconsWind
  }

  override def main(): Unit = {
    require()
    val target = dom.document.getElementById("target")
    AppRouter.router().renderIntoDOM(target)
  }
}