package gw.rating.rtm.domain.table

uses java.io.ByteArrayOutputStream
uses java.io.ObjectOutputStream
uses java.io.Serializable
uses java.util.ArrayList
uses java.util.stream.Collectors

uses gw.internal.xml.util.StreamUtil
uses gw.lang.reflect.IType
uses gw.rating.rtm.domain.EntityPersistenceAdapter
uses gw.rating.rtm.domain.EntityProcessingPersistenceAdapter
uses gw.rating.rtm.domain.ImportPersistenceAdapter
uses gw.rating.rtm.domain.RateBookVisitor
uses gw.rating.rtm.valueprovider.RateTableCellValueProviderFactory
uses org.apache.commons.lang.SerializationUtils
uses org.apache.xmlgraphics.util.io.ASCII85OutputStream
uses gw.rating.flow.util.QueryUtils

class RateTableModel implements Serializable {

  var _rateTable : RateTable
  var _factorRows : List<RateTableRow> as readonly FactorRows
  var _repo : RateTableCellValueProviderFactory as ValueProviderRepository
  var _params : entity.RateTableColumn[]
  var _factors : entity.RateTableColumn[]
  var _persistenceAdapterType : Type<EntityProcessingPersistenceAdapter>
  var _tableDef : RateTableDefinition

  @Deprecated(:value="Should pass in Persistence Adapter type instead.", :version="9.0.0")
  construct(table : RateTable) {
    this(table, EntityPersistenceAdapter.Type)
  }

  construct(tableCode : String, policyLine : String) {
    _tableDef = QueryUtils.getRateTableDefinitionForCodeAndLine(tableCode, policyLine)
    _factorRows = {}
    _params = _tableDef.SortedParameters
    _factors = _tableDef.SortedFactors
    _persistenceAdapterType = null
  }

  construct(table : RateTable, adapterType : Type<EntityProcessingPersistenceAdapter>) {
    this(table, new RateTableCellValueProviderFactory(), adapterType)
  }

  construct(otherModel : RateTableModel, adapterType : Type<EntityProcessingPersistenceAdapter>) {
    this(otherModel.RateTable, otherModel._repo, adapterType)
  }

  @Deprecated(:value="Should pass in Persistence Adapter type instead.", :version="9.0.0")
  construct(table : RateTable, repo : RateTableCellValueProviderFactory) {
    this(table, repo, EntityPersistenceAdapter.Type)
  }

  construct(table : RateTable, repo : RateTableCellValueProviderFactory, adapterType : Type<EntityProcessingPersistenceAdapter>) {
    checkNotNull(table)
    _rateTable = table
    _factorRows = new ArrayList<RateTableRow>()
    _repo = repo
    _params = table.Definition.SortedParameters
    _factors = table.Definition.SortedFactors
    _persistenceAdapterType = adapterType
  }

  property get Entity() : IType {
    return _rateTable.Definition.FactorRowEntity
  }

  property get RateBook() : RateBook {
    return _rateTable.RateBook  
  }
  
  property get RateTable() : RateTable {
    return _rateTable
  }

  property get RateTableDefinition() : RateTableDefinition {
    return _rateTable.Definition ?: _tableDef
  }

  property get FactorRows() : List<RateTableRow> {
    return _factorRows
  }
  
  property get FactorHeaders() : String[] {
    return _rateTable.Definition.SortedFactors*.ColumnName
  }

  property get ParameterHeaders() : String[] {
    return _rateTable.Definition.SortedMatchOps*.Name
  }

  function accept(visitor : RateBookVisitor) {
    visitor.visit(this)
    FactorRows.each( \ elt -> elt.accept(visitor))
    visitor.visitAfter(this)
  }

  function resetFactorRows() {
    _factorRows.clear()
  }

  /**
   * Sorts the list of Rate Factor Rows
   */
  function sortFactorRows() {
    _factorRows = _factorRows.parallelStream().sorted().collect(Collectors.toList<RateTableRow>());
  }

  function sortFactorRows(sorter : block(row1 : RateTableRow, row2 : RateTableRow) : Boolean) {
    _factorRows.sort(sorter)
  }

  /**
   * Creates and adds a new RateTableRow to the list of Rate Factor Rows.
   * Does not sort the list.
   * Please use sortFactorRows() if you need to sort the list of Rate Factor Rows.
   */
  function addFactorRow(bean : KeyableBean) {
    _factorRows.add(new RateTableRow(_rateTable.Definition, createNewAdapter(bean), _params, _factors))
  }
  
  /**
   * This should only be used for test code for now.
   */
  function addFactorRow(row : RateTableRow) {
    _factorRows.add(row)
  }
  
  function addEmptyRow() : RateTableRow {
    var adapter = createEmptyAdapter()
    var rowInfo = new RateTableRow(_rateTable.Definition, adapter, _params, _factors)
    _factorRows.add(rowInfo)
    return rowInfo
  }

  function removeFactors() {
    this.RateTable.removeFactors()
  }

  function removeFactorRow(factorRow : RateTableRow) {
    factorRow.Row.remove()
    _factorRows.remove(factorRow)
  }
  
  function incrementTableVersion() {
    var bundle = gw.transaction.Transaction.getCurrent()
    var rt = bundle.add(_rateTable)
    rt.RefTable = null
    _rateTable = rt
  }
  
  property get Reference() : boolean {
    return !Owned
  }
  property get Owned() : boolean {
    return RateTable?.Owned
  }

  private function checkNotNull(table : RateTable) {
    if (table == null) throw "Model initialized with null Rate Table"
  }

  function copyFactorRows() {
    var newRows = new ArrayList<RateTableRow>()
    for (f in _factorRows) {
      var copy = f.Row.copy()
      copy.setFieldValue("RateTable", RateTable)
      newRows.add(new RateTableRow(_rateTable.Definition, copy, _params, _factors))
    }
    _factorRows = newRows    
  }

  public function areRowsEqual(tableToCompare : RateTableModel) : boolean {
    if (tableToCompare.FactorRows.Count != this.FactorRows.Count) {
      return false
    }

    tableToCompare.sortFactorRows()
    sortFactorRows()

    //use regular for loop
    for (row1 in FactorRows index i) {
      var row2 = tableToCompare.FactorRows.get(i)
      if (row1.compareTo(row2) != 0) {
        return false
      }
    }

    return true
  }

  public function areTableRowsEqual() : boolean {
    if (_rateTable.Checksum != null) {
      return _rateTable.Checksum == calculateCheckSum()
    } else {

      var modelsAreEqual = false
      gw.transaction.Transaction.runWithNewBundle(\ bundle -> {
        var originalModel = new RateTableModel(_rateTable, EntityPersistenceAdapter.Type)
        //load model of original table in database and not in bundle. this.Factors does a database query
        _rateTable.Factors.each(\ bean -> originalModel.addFactorRow(bean))
        modelsAreEqual = originalModel.areRowsEqual(this)
      })
      return modelsAreEqual

    }
  }

  public function persistModel() {
    if (_persistenceAdapterType == ImportPersistenceAdapter.Type) {
      RateTable.removeFactors()
      FactorRows.each(\elt -> (elt.Row as EntityProcessingPersistenceAdapter).saveEntityData())
    }
  }

  public function calculateCheckSum() : String {
    this.sortFactorRows()
    var messageDigest = java.security.MessageDigest.getInstance("SHA-256")
    var data = SerializationUtils.serialize(this)
    messageDigest.update(data)
    var digestedData = messageDigest.digest()
    using (var outputStream = new ByteArrayOutputStream(digestedData.length),
           var ascii85OutputStream = new ASCII85OutputStream(outputStream)) {

      ascii85OutputStream.write(digestedData)
      return StreamUtil.toString(outputStream.toByteArray())
    }
  }

  private function createEmptyAdapter() : EntityProcessingPersistenceAdapter {
    var entityType = _rateTable.Definition.FactorRowEntity
    var adapter = _persistenceAdapterType.TypeInfo.getConstructor({Type<KeyableBean>}).Constructor.newInstance({entityType}) as EntityProcessingPersistenceAdapter
    adapter.setFieldValue("RateTable", _rateTable)
    return adapter
  }

  private function createNewAdapter(bean : KeyableBean) : EntityProcessingPersistenceAdapter {
    return _persistenceAdapterType.TypeInfo.getConstructor({KeyableBean}).Constructor.newInstance({bean}) as EntityProcessingPersistenceAdapter
  }

  private function writeObject(stream : ObjectOutputStream) {
    sortFactorRows()
    FactorRows.each(\row -> {
      _rateTable.Definition.AllColumns.each(\column -> {
        var columnValue = row.Cells.singleWhere(\elt -> elt._column == column).Value
        if (columnValue != null) {
          stream.writeObject(columnValue)
        }
      })
    })
  }
}