package ee.cone.core.c4converter.base

import java.nio.file.Path

import ee.cone.base.util.NeedSome
import ee.cone.core.c4base.HTDocsPathResolver
import ee.cone.core.c4converter.xml.XMLParser
import ee.cone.core.c4converter.xml.XMLParserTypes.{MessageBody, MessageType}
import javax.xml.transform.stream.StreamSource
import javax.xml.validation.{Schema, SchemaFactory}
import org.xml.sax.SAXParseException

import scala.util.{Failure, Success, Try}
import scala.xml.factory.XMLLoader
import scala.xml.parsing.ConsoleErrorHandler
import scala.xml.{Elem, NamespaceBinding, TopScope}

class TKX2XMLParserImpl(
  htdocs: HTDocsPathResolver
) extends XMLParser[Message] {
  val reader: XMLLoader[Elem] = {
    val schemaLang: String = javax.xml.XMLConstants.W3C_XML_SCHEMA_NS_URI
    val xsdFile: Path = htdocs(ee.cone.core.c4converter.base.PublicPath.`/schema.xsd`)
    val readOnly = java.nio.file.StandardOpenOption.READ
    val inputStream = java.nio.file.Files.newInputStream(xsdFile, readOnly)
    val xsdStream: StreamSource = new javax.xml.transform.stream.StreamSource(inputStream)
    val testJoiner = SchemaFactory.newInstance(schemaLang)

    val schema: Schema = testJoiner.newSchema(xsdStream)

    trait myErrorHandler extends ConsoleErrorHandler {
      override def error(ex: SAXParseException): Unit = {
        super.error(ex)
        throw ex
      }
    }
    val factory = javax.xml.parsers.SAXParserFactory.newInstance()
    factory.setNamespaceAware(true)
    factory.setSchema(schema)
    val validatingParser = factory.newSAXParser()
    val sitemap: XMLLoader[Elem] = new scala.xml.factory.XMLLoader[scala.xml.Elem] {
      override def parser = validatingParser
      override def adapter =
        new scala.xml.parsing.NoBindingFactoryAdapter
          with myErrorHandler

    }
    inputStream.close()
    sitemap
  }
  def fromXML(xmlStr: String): Try[Message] = {
    for {
      xml <- Try(reader.loadString(xmlStr))
      result <- ee.cone.core.c4converter.scalaxb.fromXMLEither[Message](xml) match {
        case Left(a) =>
          Failure(new Exception(a))
        case Right(b) =>
          Success(b)
      }
    } yield {
      result
    }
  }


  val scope: NamespaceBinding = ee.cone.mod.edi.tkx2_xml.xml.base.XMLProtocol.defaultScope
  //val p = new scala.xml.PrettyPrinter(192, 4)

  def toXML(message: Message, charset: String): Try[(MessageType, MessageBody)] =
    Try {
      (message.msgBody.msgbodyoption.key.getOrElse(""), ee.cone.core.c4converter.scalaxb.toXML[Message](message, "message", scope)
        .mkString("\n")
      )
    }.flatMap {
      case m@(tpe, body) =>
        fromXML(body).map(_ => m)
      case m =>
        Success(m)
    }
}