/* Copyright (c) 2005 Ricebridge. All Rights Reserved.
 *
 * This file is available under the terms and conditions of the
 * Ricebridge "Open Source API" policy; Ricebridge grants use of this
 * copyrighted work under the terms of a BSD-style license only. See
 * http://www.opensource.org/licenses/bsd-license.php for more
 * information.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 *  - Redistributions of source code must retain the above copyright
 *  notice, this list of conditions and the following disclaimer.
 *
 *  - Redistributions in binary form must reproduce the above
 *  copyright notice, this list of conditions and the following
 *  disclaimer in the documentation and/or other materials provided
 *  with the distribution.
 *
 *  - Neither the name of the Ricebridge nor the names of its
 *  contributors may be used to endorse or promote products derived
 *  from this software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.  
 */

package com.ricebridge.xmlman.test;


import com.ricebridge.xmlman.*;
import com.ricebridge.xmlman.in.*;
import com.ricebridge.xmlman.in.test.*;
import com.ricebridge.xmlman.log.*;

import com.ricebridge.util.RBTestUtil;

import org.jostraca.util.*;

import junit.framework.*;
import junit.textui.*;

import org.xml.sax.InputSource;

import java.util.*;
import java.io.*;
import java.text.*;


/** Test cases for callback methods call sequence.
 *    <p>Test file is <a href="badrec.xml">badrec.xml</a>.</p> 
 *    <p>The <b><a href="CallSequenceTest.java.html">Source Code</a></b> of this Java class 
 *    is available under a <a href="http://www.opensource.org/licenses/bsd-license.php">BSD-style license</a>.</p>
 */
public class CallSequenceTest extends TestCase {

  // test framework
  
  public CallSequenceTest( String pName ) {
    super( pName );
  }

  public static TestSuite suite() {
    return new TestSuite( CallSequenceTest.class );
  }

  public static void main( String[] pArgs ) {
    TestRunner.run( suite() );
  }


  
  // test cases

  public void testLoadNormal() throws Exception {
    File       xf = RBTestUtil.findTestFile("com/ricebridge/xmlman/test/badrec.xml");
    RecordSpec rs = new RecordSpec( "//que", 
                                    new String[] {"@rec","@q","//h:p[@class='t']"},
                                    new String[] {"rec","q","p"} );
    XmlManager xm = new XmlManager();
    xm.getXmlSpec().addNamespace("h","html");

    StringBuffer              seq  = new StringBuffer();
    SequenceRecordListener    srl  = new SequenceRecordListener( seq, false );
    xm.load( xf, rs, srl );
    Stats stats = xm.getStats();
    assertEquals( 5, stats.getTotalRecords() );
    assertEquals( 0, stats.getTotalBadRecords() );
    assertEquals( 0, xm.getBadRecords().size() );
    assertEquals( "RL-sxs,RL-sfn,RL-sp,RL-hr,RL-hr,RL-hr,RL-hr,RL-hr,RL-ep,",
                  seq.toString() );


    seq = new StringBuffer();
    srl = new SequenceRecordListener( seq, false );
    SequenceBadRecordListener sbrl = new SequenceBadRecordListener( seq );
    xm.setBadRecordListener( sbrl );
    xm.load( xf, rs, srl );
    stats = xm.getStats();
    assertEquals( 5, stats.getTotalRecords() );
    assertEquals( 0, stats.getTotalBadRecords() );
    assertEquals( 0, xm.getBadRecords().size() );
    assertEquals( "RL-sxs,RL-sfn,RL-sp,BRL-sp,RL-hr,RL-hr,RL-hr,RL-hr,RL-hr,BRL-ep,RL-ep,BRL-gbr,", seq.toString() );


    BadRecordContext brc1 = new BadRecordContext("brc1");
    seq = new StringBuffer();
    srl = new SequenceRecordListener( seq, brc1, false );
    sbrl = new SequenceBadRecordListener( seq );
    xm.setBadRecordListener( sbrl );
    xm.getXmlSpec().setIgnoreBadRecords( true );
    xm.load( xf, rs, srl );
    stats = xm.getStats();
    assertEquals( 5, stats.getTotalRecords() );
    assertEquals( 0, stats.getTotalBadRecords() );
    assertEquals( 0, xm.getBadRecords().size() );
    assertEquals( "RL-sxs,RL-sfn,RL-sp,BRL-sp,RL-hr,RL-hr,RL-hr,RL-hr,RL-hr,BRL-ep,RL-ep,BRL-gbr,",
                  seq.toString() );
  }


  public void testLoadBadRecordListener() throws Exception {
    File       xf = RBTestUtil.findTestFile("com/ricebridge/xmlman/test/badrec.xml");
    RecordSpec rs = new RecordSpec( "//que", 
                                    new String[] {"@rec","@q","//h:p[@class='t']"},
                                    new String[] {"rec","q","p"} );
    XmlManager xm = new XmlManager();
    xm.getXmlSpec().addNamespace("h","html");

    StringBuffer seq = new StringBuffer();
    SequenceRecordListener srl = new SequenceRecordListener( seq );
    SequenceBadRecordListener sbrl = new SequenceBadRecordListener( seq );
    xm.setBadRecordListener( sbrl );
    try {
      xm.load( xf, rs, srl );
      fail();
    }
    catch( XmlManagerException xme ) {
      assertTrue( XmlManagerException.CODE_bad_record == xme.getCode() );
      Stats stats = xm.getStats();
      assertEquals( 2, stats.getTotalRecords() );
      assertEquals( 1, stats.getTotalBadRecords() );
      assertEquals( 1, xm.getBadRecords().size() );
      assertEquals( "RL-sxs,RL-sfn,RL-sp,BRL-sp,RL-hr,RL-hr,BRL-hbr,BRL-ep,RL-ep,BRL-gbr,", seq.toString() );
    }

    BadRecordContext brc1 = new BadRecordContext("brc1");
    seq = new StringBuffer();
    srl = new SequenceRecordListener( seq, brc1 );
    sbrl = new SequenceBadRecordListener( seq );
    xm.setBadRecordListener( sbrl );
    xm.getXmlSpec().setIgnoreBadRecords( true );
    xm.load( xf, rs, srl );
    Stats stats = xm.getStats();
    assertEquals( 5, stats.getTotalRecords() );
    assertEquals( 3, stats.getTotalBadRecords() );
    assertEquals( 3, xm.getBadRecords().size() );
    assertEquals( "RL-sxs,RL-sfn,RL-sp,BRL-sp,RL-hr,RL-hr,BRL-hbr,RL-hr,RL-hr,BRL-hbr,RL-hr,BRL-hbr,BRL-ep,RL-ep,BRL-gbr,",
                  seq.toString() );
  }


  public void testSaveNormal() throws Exception {
    File       xf = RBTestUtil.findTestFile("com/ricebridge/xmlman/test/save.xml");
    RecordSpec rs = new RecordSpec( "/foo/bar/que", 
                                    new String[] {"/foo/bar/@b","@q","h:div/h:p/@class","h:div/h:p"},
                                    new String[] {"rec","q","class","p"} );
    List data = new ArrayList();
    data.add( ListUtil.make( "b1","q1","t","t1") );
    data.add( ListUtil.make( "b1","q2","t","t2") );
    data.add( ListUtil.make( "b1","q3","t","t3") );
    data.add( ListUtil.make( "b2","q4","t","t4") );
    data.add( ListUtil.make( "b2","q5","t","t5") );
    
    XmlManager xm = new XmlManager();
    xm.getXmlSpec().addNamespace("h","html");

    StringBuffer              seq  = new StringBuffer();
    SequenceRecordProvider    srp  = new SequenceRecordProvider( data, seq, false );
    FileUtil.writeFile( xf, "" );
    xm.save( xf, rs, srp );
    assertEquals( "RP-sxs,RP-sfn,RP-sp,RP-hnr,RL-nr,RP-hnr,RL-nr,RP-hnr,RL-nr,RP-hnr,RL-nr,RP-hnr,RL-nr,RP-hnr,RP-ep,",
                  seq.toString() );
    Stats stats = xm.getStats();
    assertEquals( 5, stats.getTotalRecords() );
    assertEquals( 0, stats.getTotalBadRecords() );
    assertEquals( 0, xm.getBadRecords().size() );



    seq = new StringBuffer();
    srp = new SequenceRecordProvider( data, seq, false );
    SequenceBadRecordListener sbrl = new SequenceBadRecordListener( seq );
    xm.setBadRecordListener( sbrl );
    FileUtil.writeFile( xf, "" );
    xm.save( xf, rs, srp );
    assertEquals( "RP-sxs,RP-sfn,RP-sp,BRL-sp,RP-hnr,RL-nr,RP-hnr,RL-nr,RP-hnr,RL-nr,RP-hnr,RL-nr,RP-hnr,RL-nr,RP-hnr,BRL-ep,RP-ep,",
                  seq.toString() );
    stats = xm.getStats();
    assertEquals( 5, stats.getTotalRecords() );
    assertEquals( 0, stats.getTotalBadRecords() );
    assertEquals( 0, xm.getBadRecords().size() );
  }


  public void testSaveBadRecordListener() throws Exception {
    File       xf = RBTestUtil.findTestFile("com/ricebridge/xmlman/test/save.xml");
    RecordSpec rs = new RecordSpec( "/foo/bar/que", 
                                    new String[] {"/foo/bar/@b","@q","h:div/h:p/@class","h:div/h:p"},
                                    new String[] {"rec","q","p","pt"} );
    List data = new ArrayList();
    data.add( ListUtil.make( "b1","q1","t","t1") );
    data.add( ListUtil.make( "b1","q2","t","t2") );
    data.add( ListUtil.make( "b1","q3","t","t3") );
    data.add( ListUtil.make( "b2","q4","t","t4") );
    data.add( ListUtil.make( "b2","q5","t","t5") );
    
    XmlManager xm = new XmlManager();
    xm.getXmlSpec().addNamespace("h","html");

    StringBuffer              seq  = new StringBuffer();
    SequenceRecordProvider    srp  = new SequenceRecordProvider( data, seq, true );
    SequenceBadRecordListener sbrl = new SequenceBadRecordListener( seq );
    xm.setBadRecordListener( sbrl );
    FileUtil.writeFile( xf, "" );
    try {
      xm.save( xf, rs, srp );
      fail();
    }
    catch( Exception e ) {
      assertEquals( XmlManagerException.CODE_bad_record, ((XmlManagerException)e).getCode() );
      assertEquals( "RP-sxs,RP-sfn,RP-sp,BRL-sp,RP-hnr,RL-nr,RP-hnr,RL-nr,BRL-hbr,BRL-ep,RP-ep,",
                    seq.toString() );
      Stats stats = xm.getStats();
      assertEquals( 2, stats.getTotalRecords() );
      assertEquals( 1, stats.getTotalBadRecords() );
      assertEquals( 1, xm.getBadRecords().size() );
    }


    xm.getXmlSpec().setIgnoreBadRecords( true );
    seq = new StringBuffer();
    srp = new SequenceRecordProvider( data, seq, true );
    sbrl = new SequenceBadRecordListener( seq );
    xm.setBadRecordListener( sbrl );
    FileUtil.writeFile( xf, "" );
    xm.save( xf, rs, srp );
    assertEquals( "RP-sxs,RP-sfn,RP-sp,BRL-sp,RP-hnr,RL-nr,RP-hnr,RL-nr,BRL-hbr,RP-hnr,RL-nr,RP-hnr,RL-nr,BRL-hbr,RP-hnr,RL-nr,BRL-hbr,RP-hnr,BRL-ep,RP-ep,", seq.toString() );
    Stats stats = xm.getStats();
    assertEquals( 5, stats.getTotalRecords() );
    assertEquals( 3, stats.getTotalBadRecords() );
    assertEquals( 3, xm.getBadRecords().size() );
  }


  public static class BadRecordContext {
    public String iValue;
    public BadRecordContext( String pValue ) { iValue = pValue; } 
    public String toString() { return "BadRecordContext:"+iValue; }
  }



  public class SequenceRecordListener extends RecordListenerSupport {
    private StringBuffer iSequence = null;
    private boolean      iHasFailures = false;
    private BadRecordContext iBRC = null;

    public SequenceRecordListener( StringBuffer pSequence ) {
      this( pSequence, true );
    }

    public SequenceRecordListener( StringBuffer pSequence, boolean pHasFailures ) { 
      iSequence    = pSequence; 
      iHasFailures = pHasFailures;
    }

    public SequenceRecordListener( StringBuffer pSequence, BadRecordContext pBRC) { 
      this( pSequence, pBRC, true );
    }
    public SequenceRecordListener( StringBuffer pSequence, BadRecordContext pBRC, boolean pHasFailures ) { 
      this(pSequence,pHasFailures); 
      iBRC = pBRC; 
    }


    protected void setXmlSpecImpl( XmlSpec pXmlSpec ) {
      iSequence.append("RL-sxs,");
    }

    protected void setFieldNamesImpl( String[] pFieldNames ) {
      iSequence.append("RL-sfn,");
    }

    protected void startProcessImpl() {
      iSequence.append("RL-sp,");
    }

    protected void endProcessImpl() {
      iSequence.append("RL-ep,");
    }

    public BadRecord handleRecordImpl( String[] pRecord, long pRecordNumber ) {
      iSequence.append("RL-hr,");

      if( iHasFailures && "bad".equals(pRecord[0]) ) {
        if( null == iBRC ) {
          return new BadRecord( "que", pRecordNumber, pRecord, "bad");
        }
        else {
          return new BadRecord( "que", pRecordNumber, pRecord, "bad", iBRC );
        }
      }

      return null;
    }
  }


  public class SequenceBadRecordListener extends CollectingBadRecordListener {
    private ArrayList iBadRecs = new ArrayList();
    private StringBuffer iSequence = null;    

    public SequenceBadRecordListener( StringBuffer pSequence ) {
      iSequence = pSequence;
    }

    protected void startProcessImpl() {
      iSequence.append("BRL-sp,");
    }

    protected void endProcessImpl() {
      iSequence.append("BRL-ep,");
    }


    protected void handleBadRecordImpl( BadRecord pBadRecord ) {
      iBadRecs.add( pBadRecord );
      iSequence.append("BRL-hbr,");
    }

    protected List getBadRecordsImpl() {
      iSequence.append("BRL-gbr,");
      return iBadRecs;
    }
  }



  public class SequenceRecordProvider extends StringListRecordProvider {
    private StringBuffer     iSequence    = null;
    private boolean          iHasFailures = false;

    public SequenceRecordProvider( List pData, StringBuffer pSequence ) {
      this( pData, pSequence, true );
    }

    public SequenceRecordProvider( List pData, StringBuffer pSequence, boolean pHasFailures ) { 
      super( pData );
      iSequence    = pSequence; 
      iHasFailures = pHasFailures;
    }

    protected void setXmlSpecImpl( XmlSpec pXmlSpec ) {
      iSequence.append("RP-sxs,");
    }

    protected void setFieldNamesImpl( String[] pFieldNames ) {
      iSequence.append("RP-sfn,");
    }

    protected void startProcessImpl() {
      iSequence.append("RP-sp,");
      super.startProcessImpl();
    }

    protected void endProcessImpl() {
      iSequence.append("RP-ep,");
      super.endProcessImpl();
    }

    public boolean hasNextRecordImpl() {
      iSequence.append("RP-hnr,");
      return super.hasNextRecordImpl();
    }

    public String[] nextRecordImpl() {
      iSequence.append("RL-nr,");
      String[] record = super.nextRecordImpl();

      if( iHasFailures && (2 == iRecordIndex || 4 == iRecordIndex || 5 == iRecordIndex ) ) {
        throw new RuntimeException( "bad rec "+iRecordIndex );
      }

      return record;
    }
  }
  
}