/**
 * 
 */
package org.vamsas.test.simpleclient;

import java.io.File;
import java.io.IOException;
import java.util.Date;
import java.util.Hashtable;
import java.util.Vector;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.exolab.castor.xml.MarshalException;
import org.exolab.castor.xml.ValidationException;
import org.vamsas.client.ClientHandle;
import org.vamsas.client.IVorbaIdFactory;
import org.vamsas.client.SessionHandle;
import org.vamsas.client.UserHandle;
import org.vamsas.client.Vobject;
import org.vamsas.client.VorbaId;
import org.vamsas.client.simpleclient.AppDataOutputStream;
import org.vamsas.client.simpleclient.FileWatcher;
import org.vamsas.client.simpleclient.IdFactory;
import org.vamsas.client.simpleclient.SessionFile;
import org.vamsas.client.simpleclient.SimpleDocBinding;
import org.vamsas.client.simpleclient.SimpleDocument;
import org.vamsas.client.simpleclient.VamsasArchive;
import org.vamsas.client.simpleclient.VamsasArchiveReader;
import org.vamsas.client.simpleclient.VamsasFile;
import org.vamsas.objects.core.AppData;
import org.vamsas.objects.core.ApplicationData;
import org.vamsas.objects.core.User;
import org.vamsas.objects.core.VamsasDocument;
import org.vamsas.objects.utils.AppDataReference;
import org.vamsas.objects.utils.DocumentStuff;
import org.vamsas.objects.utils.ProvenanceStuff;
import org.vamsas.objects.utils.SeqSet;
import org.vamsas.objects.utils.document.VersionEntries;
import org.vamsas.test.objects.Core;

/**
 * @author jimp
 *  test the VamsasFile routines for watching, reading and updating a vamsas document jar file.
 *  simple document access base class.
 */
public class ArchiveClient extends IdFactory {
  
  private Log log = LogFactory.getLog(ArchiveClient.class);
  // protected UserHandle user=null;
  // protected ClientHandle me = new ClientHandle("ArchiveClient","0.01");
  VamsasFile vsess;
  
  /**
   * @param user
   * @param vsess
   */
  public ArchiveClient(UserHandle user, VamsasFile vsess) {
    super(new SessionHandle("vamsasfile://"+vsess.getVamsasFile()), new ClientHandle("ArchiveClient","0.01"), user);
    this.vsess = vsess;
    valid();
  }
  private void _openVsess(File vsess) {
    try {
      this.vsess = new VamsasFile(vsess);
    }
    catch (Exception e) {
      log.error("Couldn't open session for file "+vsess,e);
      this.vsess = null;
    }
  }
  public ArchiveClient(String username, String organization, File vsess) {
    super(new SessionHandle("vamsasfile://"+vsess), new ClientHandle("ArchiveClient","0.01"), new UserHandle(username, organization));
    _openVsess(vsess);
    valid();
  }
  public ArchiveClient(String username, String organization, String clientName, String clientVersion, File vsess) {
    super(new SessionHandle("vamsasfile://"+vsess), new ClientHandle(clientName, clientVersion), new UserHandle(username, organization));
    _openVsess(vsess);
    valid();
  }
  public void valid() {
    if (vsess==null)
      throw new Error("ArchiveClient instance is invalid!.");
  }

  /**
   * watch the document file for updates.
   * @param time - length of time to watch for.
   * @return read only IO interface for session document.
   */
  public ClientDoc watch(long time) {
    valid();
    FileWatcher watcher = new FileWatcher(vsess.getVamsasFile());
    long endtime=System.currentTimeMillis()+time;
    try {
      org.vamsas.client.simpleclient.Lock doclock;
      watcher.setState();
      do {
        Thread.sleep(50); // tuning.
        doclock=watcher.getChangedState();
      } while (doclock==null && (time==0 || endtime>System.currentTimeMillis()));
      if (doclock==null)
        return null;
      else {
        doclock = vsess.getLock(doclock);
        VamsasArchiveReader varc = new VamsasArchiveReader(vsess.getVamsasFile());
        return _getReadonly(varc);
      }
    } catch (Exception e) {
      log.error("Whilst watching file "+vsess.getVamsasFile(), e);
    }
    return null;
  }

  // from ClientDocument.getClientAppdata
  private AppData[] getAppData(VamsasDocument doc) {
    if (doc==null) {
      log.debug("extractAppData called for null document object");
      return null;
    }
    AppData appsGlobal=null, usersData=null;
    Vector apldataset = AppDataReference.getUserandApplicationsData(
        doc, this.getUserHandle(), this.getClientHandle());
    if (apldataset!=null) {
      if (apldataset.size()>0) {
        AppData clientdat = (AppData) apldataset.get(0);
        if (clientdat instanceof ApplicationData) {
          appsGlobal = (ApplicationData) clientdat;
          if (apldataset.size()>1) {
            clientdat = (AppData) apldataset.get(1);
            if (clientdat instanceof User) {
              usersData = (User) clientdat;
            }
            if (apldataset.size()>2)
              log.info("Ignoring additional ("+(apldataset.size()-2)+") AppDatas returned by document appdata query.");
          } 
        } else {
          log.warn("Unexpected entry in AppDataReference query: id="+clientdat.getVorbaId()+" type="+clientdat.getClass().getName());
        }
        apldataset.removeAllElements(); // destroy references.
      }
    }
    return new AppData[] { appsGlobal, usersData};
  }
  
  protected ClientDoc _getReadonly(VamsasArchiveReader vreader) throws IOException, ValidationException, MarshalException {
    valid();
    if (vreader!=null) {
      SimpleDocBinding docb = new SimpleDocBinding();
      docb.setVorba(this);
      VamsasDocument d;
      d = docb.getVamsasDocument(vreader);
      
      if (d!=null) {
        ClientDoc creader = new ClientDoc(d, null, vreader, getClientHandle().getClientUrn(), getProvenanceUser(), getVorbaIdHash());
        return creader;
      }
    }
    return null;
  }  
  /**
   * from SimpleClient
   * @return user field for a provenance entry
   */
  protected String getProvenanceUser() {
    return new String(getUserHandle().getFullName()+" ["+getClientHandle().getClientUrn()+"]");
  }
  
  public ClientDoc getUpdateable() {
    valid();
    try {
      vsess.getLock();
      VamsasArchive varc = new VamsasArchive(vsess, true, false); // read archive, write as vamsasDocument, don't erase original contents.
      varc.setVorba(this);
      VamsasDocument d = varc.getVamsasDocument(getProvenanceUser(), "Created new document.", VersionEntries.latestVersion()); // VAMSAS: provenance user and client combined
      
      if (d==null) {
        log.warn("Backing out from opening a VamsasArchive writable IO session");
        varc.cancelArchive();
        return null;
      }      
      ClientDoc cdoc = new ClientDoc(d, varc, varc.getOriginalArchiveReader(), getClientHandle().getClientUrn(), getProvenanceUser(), getVorbaIdHash());
      return cdoc;
      // do appHandle?
    } catch (Exception e) {
      log.error("Failed to get Updateable version of "+vsess.getVamsasFile(), e);
    }
    return null;
  }
  /**
   * trust client to not do anything stupid to the document roots which will now be written to the archive.
   * @param cdoc
   * @return true if write was a success.
   */
  public boolean doUpdate(ClientDoc cdoc) {
    valid();
    if (cdoc==null) {
      log.warn("Invalid ClientDoc passed to org.vamsas.test.simpleclient.doUpdate()");
      return false;
    }
    if (cdoc.iohandler==null) {
      log.warn("Read only ClientDoc object passed to org.vamsas.test.simpleclient.doUpdate()");
      return false;
    }
    if (cdoc.iohandler.getVorba()!=this) {
      log.error("Mismatch between ClientDoc instances and ArchiveClient instances!");
      return false;
    }
    try {
      // do any appDatas first.
      if (cdoc.iohandler.transferRemainingAppDatas())
        log.debug("Remaining appdatas were transfered.");
      cdoc.iohandler.putVamsasDocument(cdoc.doc);
      cdoc.iohandler.closeArchive();
      cdoc.iohandler=null;
      cdoc = null;
      vsess.unLock();
    } catch (Exception e) {
      log.warn("While updating archive in "+vsess.getVamsasFile(),e);
      return false;
    }
    return true;
  }
  /**
   * @param args
   */
  public static void usage() {
    throw new Error("Usage: Username Organization VamsasFile [command,args]*");
  }
  public static void main(String[] args) {
    // really simple.
    if (args.length<3)
      usage();
    
    ArchiveClient client = new ArchiveClient(args[0],args[1], new File(args[2]));
    ClientDoc cdoc=null;
    // sanity test.
    try {
      cdoc = client.getUpdateable();
      // ArchiveReports.reportDocument(cdoc.doc, cdoc.getReader(), true, System.out);
      System.out.println("Report Roots :");
      ArchiveReports.rootReport(cdoc.getVamsasRoots(), true, System.out);
      cdoc.addVamsasRoot(Core.getDemoVamsas());
      System.out.println("Doing update.");
      client.doUpdate(cdoc);
      cdoc = null;
      int u=5;
      while (--u>0) {
        System.out.println("Watch for more... ("+u+" left)");
        cdoc = client.watch(0);
        if (cdoc!=null) {
          System.out.println("****\nUpdate detected at "+new Date());
          ArchiveReports.reportDocument(cdoc.doc, cdoc.getReader(), true, System.out);
        } else {
          System.out.println("!!!! Null document update detected at "+new Date());
        }
      }
    }
    catch (Exception e) {
      client.log.error("Broken!", e);
    }
    System.out.println("Finished at "+new Date());
  }
  public org.vamsas.client.Vobject getObject(VorbaId id) {
    Hashtable idhash = this.getVorbaIdHash();
    if (idhash!=null && idhash.containsKey(id))
      return (Vobject) idhash.get(id);
    return null;
    }
}