//设置package包名称以及导入依赖的类
package org.argus.jawa.summary.parser

import java.io.StringReader

import org.antlr.v4.runtime.misc.ParseCancellationException
import org.antlr.v4.runtime.{BailErrorStrategy, CharStreams, CommonTokenStream, NoViableAltException}
import org.argus.jawa.summary.rule.SummaryFile
import org.argus.jawa.summary.grammar.{SafsuLexer, SafsuParser}


object SummaryParser {
  def apply(source: String): SummaryFile =
    parse(source)

  @throws[SummaryParserException]
  def parse(source: String): SummaryFile = {
    val reader = new StringReader(source)
    val input = CharStreams.fromReader(reader)
    val lexer = new SafsuLexer(input)
    val cts = new CommonTokenStream(lexer)
    val parser = new SafsuParser(cts)
    parser.setErrorHandler(new BailErrorStrategy)
    try {
      SummaryParserVisitor(parser.summaryFile())
    } catch {
      case oie: IndexOutOfBoundsException =>
        throw SummaryParserException(oie)
      case nvae: NoViableAltException =>
        throw SummaryParserException(nvae)
      case pce: ParseCancellationException =>
        throw SummaryParserException(pce.getCause)
    }
  }
}

case class SummaryParserException(cause: Throwable) extends Exception(cause.getMessage) 

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

import org.scalatest.FunSuite
import ast2._
import org.antlr.v4.runtime.ANTLRInputStream
import org.antlr.v4.runtime.CommonTokenStream
import intermediate.Intermediate


class CodegenTests extends FunSuite {
  
  def intermediate(filename: String, code: String, runtime: Runtime) = {

    try {
      val unit = Main.process(filename, code, runtime)
      val module = Intermediate.codegen(unit)
      println(module)
      val bytes = Codegen.codegen(module)
      Main.execute(unit.module.name, bytes, runtime)
    } 
    catch {
      case e: TypeException =>
        Main.showException(e, code)
        throw e
    }
  }
  
  def ty(code: String) = {
    val lexer = new TypegrammarLexer(new ANTLRInputStream(code))
    val parser = new TypegrammarParser(new CommonTokenStream(lexer))
    val cst = parser.ty()
    val gty = new TypeVisitor().visitTy(cst)
    val ty = Typegrammar.toType(gty)
    ty
  }

  def matches(in: Any, exp: String) = {
    val exp2 = "^" + exp.replace("(", "\\(").replace(")", "\\)") + "$"
    val r = exp.r.findFirstIn(in.toString)
    r match {
      case Some(_) => true
      case None => false
    }
  }

  test("Class as Eq") {
    val runtime = new Runtime()
    val code = """
      module test

      a = { z => { x => x } ({ x => x + z } ) } (2)
      a(1)

      """
    val ret = intermediate("test", code, runtime)
    println(ret)
  }
} 

//设置package包名称以及导入依赖的类
package definiti.core.parser.project

import java.nio.file.{Files, Path, Paths}

import definiti.core.parser.antlr.{CoreDefinitionLexer, CoreDefinitionParser}
import definiti.core.parser.api.CoreDefinitionASTParser
import definiti.core.utils.CollectionUtils.scalaSeq
import definiti.core.{ClassDefinition, ReferenceContext}
import org.antlr.v4.runtime.{CharStreams, CommonTokenStream}

trait CoreParser {
  lazy val core: Seq[ClassDefinition] = {
    extractCoreDefinitionFiles()
      .map(_.toAbsolutePath.toString)
      .flatMap(parseCoreDefinitionFile)
  }

  lazy val coreContext: ReferenceContext = {
    ReferenceContext(
      classes = core,
      verifications = Seq.empty,
      namedFunctions = Seq.empty,
      requirements = Seq.empty
    )
  }

  private def extractCoreDefinitionFiles(): Seq[Path] = {
    val source = Paths.get("src", "main", "resources", "api")
    scalaSeq(Files.find(source, 1000, (path, _) => String.valueOf(path).endsWith(".definition")))
  }

  private def parseCoreDefinitionFile(fileName: String): Seq[ClassDefinition] = {
    val in = CharStreams.fromFileName(fileName)
    val lexer = new CoreDefinitionLexer(in)
    val tokens = new CommonTokenStream(lexer)
    val parser = new CoreDefinitionParser(tokens)
    val coreDefinition = parser.coreDefinition()
    CoreDefinitionASTParser.definitionContextToAST(coreDefinition)
  }
}