package gw.rating.rtm.domain.migration

uses gw.api.locale.DisplayKey
uses java.util.Date
uses gw.api.database.Query
uses gw.rating.rtm.util.ProductModelUtils
uses gw.api.productmodel.PolicyLinePatternLookup
uses gw.api.extension.ExtensionInterfaces

/**
 * Perform the following validation on a <code>RateBook</code>:
 * <ul>
 * <li>Activation date is not in the future</li>
 * <li>The <code>RateBook</code> does not conflict with an existing one</li>
 * <li>The <code>RateBook</code>'s public ID is unique</li>
 * <li>The <code>RateBook</code> contains at least one <code>RateTable</code> 
 * and no empty <code>RateTable</code>s is included</li>
 * <li>The <code>RateBook</code>'s status is not 'draft'</li>
 * </ul>
 */
class RateBookImportValidator extends BeanImportValidator<RateBook> {
 
  /**
   * Validate a <code>RateBook</code>
   * 
   * @param <code>RateBook</code> entiry to validate
   * 
   * @return true is the <code>RateBook</code> is valid; false otherwise
   */    
  override function valid(bean : RateBook) : boolean {
    policyLineExists(bean)
    offeringExists(bean)
    isActivationDateInPast(bean)
    noConflictingBook(bean)
    noMoreThanOneRateRoutineVersion(bean)
    hasUniquePublicId(bean)
    notEmpty(bean)
    nonDraft(bean)
    userHasPermissions(bean)
        
    return _validationErrors.Empty    
  }
  
  private function policyLineExists(book : RateBook) {
    if (book.PolicyLine == null) {
      return // generic book
    }

    var policyLine = PolicyLinePatternLookup.getByPublicID(book.PolicyLine)
    if (policyLine == null) {
      addError(DisplayKey.get("Web.Rating.Errors.PolicyLineDoesNotExist", book.BookCode, book.PolicyLine))
    }
  }
     
  private function offeringExists(book : RateBook) {
    var offerings = ProductModelUtils.getOfferingsFor(book.PolicyLine)
    if (book.BookOffering != null and !offerings.contains(book.BookOffering)) {
      addError(DisplayKey.get("Web.Rating.Errors.OfferingDoesNotExist", book.BookCode, book.BookOffering))
    }
  }
    
  private function notEmpty(book : RateBook) { 
    if (book.Status != RateBookStatus.TC_DRAFT) {
      hasTables(book)
      includeEmptyTables(book)
    }
  }
  
  private function isActivationDateInPast(book : RateBook) {
    if (book.LastStatusChangeDate.after(Date.CurrentDate)) {
      addError(DisplayKey.get("Web.Rating.Errors.BookActivatedInFuture", book.BookCode))
    }
  }
  
  private function noConflictingBook(book : RateBook) {
    var found = Query.make(entity.RateBook)
            .compare(RateBook#BookEdition, Equals, book.BookEdition)
            .compare(RateBook#BookCode, Equals, book.BookCode)
            .compare(RateBook#PolicyLine, Equals, book.PolicyLine).select().Count > 0
              
    if (found) {
      addError(DisplayKey.get("Web.Rating.Errors.BookAlreadyExists", book.BookCode))
    }
  }
  
  private function noMoreThanOneRateRoutineVersion(book : RateBook) {
    var rateRoutineCodes = book.CalcRoutines*.Code.toSet()
    rateRoutineCodes.each(\ code -> { 
        if (book.CalcRoutines.countWhere(\ cr -> cr.Code == code) > 1) {
          addError(DisplayKey.get("Web.Rating.Errors.MultipleRateRoutineVersions", book.BookCode, code))
        }
      }
    )
  }

  private function hasUniquePublicId(book : RateBook) {
    if (Query.make(entity.RateBook).compare(RateBook#PublicID, Equals, book.PublicID).select().Count > 0) {
      addError(DisplayKey.get("Web.Rating.Errors.BookWithPublicIdExists", book.BookCode, book.PublicID))
    }
  }
  
  private function hasTables(book : RateBook) {
    if (book.RateTables.IsEmpty) {
      addError(DisplayKey.get("Web.Rating.Errors.NonDraftBookHasNoTables", "'${book.BookCode}'"))
    }  
  }
  
  private function nonDraft(book : RateBook) {
    if (book.isDraft()) {
      addError(DisplayKey.get("Web.Rating.Errors.ImportingDraftBook", book.BookCode))
    }  
  }
  
  private function includeEmptyTables(book : RateBook) {
    book.OwnedTables.each(\ ownedTable ->  {
      if (not ownedTable.hasInsertedFactors()) {
        addError(DisplayKey.get("Web.Rating.Errors.BookContainsEmptyTable", "'${book.BookCode}'", "'${ownedTable.Definition.TableCode}'"))  
      }          
    })
  }
  
  private function userHasPermissions(book : RateBook){
  
    if(not ExtensionInterfaces.IRateBookImportValidatorExtensions.currentUserCanImportActiveRateBook(book)){
      addError(DisplayKey.get("Web.Rating.Errors.ImportingActiveRateBookWithoutPermission", book.BookCode))  
    }
    
  }
  
}