//
//  $Id$
//-----------------------------------------------------------------------
//
//            (c) Copyright 2006 by GATS, Inc.,
//     11864 Canon Blvd, Suite 101, Newport News VA 23606
//
//  All Rights Reserved. No part of this software or publication may be
//  reproduced, stored in a retrieval system, or transmitted, in any form
//  or by any means, electronic, mechanical, photocopying, recording, or
//  otherwise without the prior written permission of GATS, Inc.
//
//-----------------------------------------------------------------------
//
// Module:	GracePlot.cpp
//
// Author:	John Burton	<john@traveler.gats-inc.com>
//
// Date:  	Thu May  4 13:16:01 2006
//
//-----------------------------------------------------------------------
//
// Modification History:
//
//     $Log$
//
//-----------------------------------------------------------------------
//
//-----------------------------------------------------------------------
// Include Files:
//-----------------------------------------------------------------------
//

#include "GracePlot.h"


#include <cstdlib>
//
//-----------------------------------------------------------------------
// Defines and Macros:
//-----------------------------------------------------------------------
//



//
//-----------------------------------------------------------------------
// Global Variables:
//-----------------------------------------------------------------------
//

using namespace gracesc;

//
//-----------------------------------------------------------------------
// Utility Routines:
//-----------------------------------------------------------------------
//

XmgraceGraph::XmgraceGraph(unsigned int number)
{
  graph_number = number;
  linemax      = 0;
  newline      = true;
  GracePrintf("g%d hidden false",graph_number);
}

    
XmgraceGraph& XmgraceGraph::operator << (const char* command)
{
  GracePrintf("with g%d",graph_number);
  GracePrintf("%s",command);
  return(*this);
}
    
XmgraceGraph& XmgraceGraph::operator << (const double& variable){
  if(newline){
    data.push_back(std::vector<double>());  
    data[data.size()-1].push_back(variable);
    newline=false;
  }
  else{
    data[data.size()-1].push_back(variable);
  }
  
  return(*this);
}
    
void XmgraceGraph::operator << (void (*func)(XmgraceGraph&)){
  func(*this);
}


void XmgraceGraph::clear(void){
  for(unsigned int i=0;i<linemax;i++){
    GracePrintf("kill g%d.s%d saveall",graph_number,i);
  }
  linemax=0;
}

void XmgraceGraph::draw(void){
  if ( data.empty() == false ){
    unsigned int lasttime=data.size();
    unsigned int lastline=data[0].size();
    if(lastline>linemax){
      linemax=lastline;
    }
    for(unsigned int i=0;i<lasttime;i++){
      for(unsigned int j=1;j<lastline;j++){
	GracePrintf("g%d.s%d point %g,%g",graph_number,j-1,data[i][0],data[i][j]);
      }
    }
    for(unsigned int i=0;i<lasttime;i++){
      data[i].clear();
    }
    data.clear();
  }
}


void XmgraceGraph::autoscale(void) {
  GracePrintf("with g%d",graph_number);
  GracePrintf("AUTOSCALE");
}

void XmgraceGraph::timestamp(){
  GracePrintf ( "timestamp on");
  GracePrintf ( "timestamp 0.83, 0.03");
  GracePrintf ( "timestamp color 1");
  GracePrintf ( "timestamp rot 0");
  GracePrintf ( "timestamp font 4");
  GracePrintf ( "timestamp char size 0.330000");
}

void XmgraceGraph::Scale_xAxis(int LogType,int xmin,int xmax)
{
  if (LogType ==1){
    GracePrintf ( "xaxes scale Logarithmic");
//    GracePrintf ( "xaxis  tick major 10");
//    GracePrintf ( "xaxis tick minor ticks 9");
    GracePrintf ( "world xmin %d",xmin);
    GracePrintf ( "world xmax %d",xmax);
    //GracePrintf ( "xaxis ticklabel prec 7");
  }   
  else
  {
    int tickmajor = (xmax-xmin)/5;
    GracePrintf ( "world xmin %d",xmin);
    GracePrintf ( "world xmax %d",xmax);
//    GracePrintf ( "xaxis tick major %d",tickmajor);
  }   
  
}	

void XmgraceGraph::Scale_xAxis(int LogType,double xmin,double xmax)
{
  if (LogType ==1){
    GracePrintf ( "xaxes scale Logarithmic");
//    GracePrintf ( "xaxis  tick major 10");
//    GracePrintf ( "xaxis tick minor ticks 9");
    GracePrintf ( "world xmin %e",xmin);
    GracePrintf ( "world xmax %e",xmax);
    //GracePrintf ( "xaxis ticklabel prec 7");
  }   
  else
  {
    double tickmajor = (xmax-xmin)/5;
    GracePrintf ( "world xmin %e",xmin);
    GracePrintf ( "world xmax %e",xmax);
//    GracePrintf ( "xaxis tick major %e",tickmajor);
  }   
  
//	GracePrintf ( "redraw");
}	


//template<class T>
void XmgraceGraph::Scale_yAxis(int LogType,int vmin,int vmax)
{
  if (LogType ==1){
    GracePrintf ( "yaxes scale Logarithmic");
//    GracePrintf ( "yaxis  tick major 10");
//    GracePrintf ( "yaxis tick minor ticks 9");
    if (vmax >vmin)
    {
      GracePrintf ( "world ymin %d",vmin);
      GracePrintf ( "world ymax %d",vmax);
    }	 
  }   
  if (LogType == 0)
  {
    int tickmajor = (int)(vmax-vmin)/5;
//    GracePrintf ( "yaxis tick major %d",tickmajor);
    if (vmax >vmin)
    {
      GracePrintf ( "world ymin %d",vmin);
      GracePrintf ( "world ymax %d",vmax);
    }	 
  }   
}

void XmgraceGraph::Scale_yAxis(int LogType,double vmin,double vmax)
{
  if (LogType ==1){
    GracePrintf ( "yaxes scale Logarithmic");
//    GracePrintf ( "yaxis  tick major 10");
//    GracePrintf ( "yaxis tick minor ticks 9");
    if (vmax >vmin)
    {
      GracePrintf ( "world ymin %e",vmin);
      GracePrintf ( "world ymax %e",vmax);
    }	 
  }   
  if (LogType == 0)
  {
    double tickmajor = (vmax-vmin)/5.0;
//    GracePrintf ( "yaxis tick major %e",tickmajor);
    if (vmax >vmin)
    {
      GracePrintf ( "world ymin %e",vmin);
      GracePrintf ( "world ymax %e",vmax);
    }	 
  }   
}   


void XmgraceGraph::Display_titles (std::string title, std::string subtitle, std::string xlabel, std::string ylabel)
{
  
  GracePrintf ( "title size 1.2");
  GracePrintf ( "title \"%s\"",title.c_str()); 
  GracePrintf ( "subtitle \"%s\"",subtitle.c_str());
  GracePrintf ( "xaxis  label place 0.0, 0.05");
  GracePrintf ( "xaxis label \"%s\"",xlabel.c_str());
  GracePrintf ( "yaxis label \"%s\"",ylabel.c_str()); 
  //GracePrintf ( "redraw");
}


void XmgraceGraph::SetLegend(int ndx, std::string legend)
{
  GracePrintf ("legend on");
  GracePrintf ("legend string %d \"%s\"", ndx,legend.c_str());
}


void XmgraceGraph::Set_legend_location(char *xlocation, char *ylocation)
{
  GracePrintf ( "legend on");
  GracePrintf ( "legend x1 %s",xlocation);
  GracePrintf ( "legend y1 %s",ylocation);
  GracePrintf ( "legend layout 0");
  return;
}


Xmgrace::Xmgrace(unsigned int size)
{
  max_graph_size = -1;
  init();
  add(size);
}


Xmgrace::Xmgrace( const std::string &parameter_file,unsigned int size )
{
  max_graph_size = -1;
  init(parameter_file);
  add(size);
}


void Xmgrace::add(unsigned int size)
{
  for(unsigned int i=0;i<size;i++){
    max_graph_size++;
    graph.push_back(XmgraceGraph(max_graph_size));
  }
}

Xmgrace& Xmgrace::operator << (const char* command)
{
  GracePrintf("%s",command);
  return(*this);
}

XmgraceGraph& Xmgrace::operator [] (unsigned int number)
{
  return graph[number];
}

bool Xmgrace::open(void)
{
  return GraceIsOpen();
}


void Xmgrace::redraw(void)
{
  GracePrintf("redraw");
}

static void read_command_file(const std::string &filename)
  {
    std::ifstream ifs (filename.c_str(), std::ios::in);
    if (ifs.fail()){
      std::cerr << "Error(load commands): unable to open file(" << filename << ")" << std::endl;
      exit(1);
    }
    char buffer[BUFSIZE];
    while (!ifs.eof()){
      ifs.getline(buffer, BUFSIZE);
      GraceCommand(buffer);
    }
    ifs.close();
  }



void XmgraceGraph::load_commands(const std::string & filename)
{
  GracePrintf("with g%d",graph_number);
  read_command_file(filename);
}


void Xmgrace::load_commands(const std::string & filename)
{
  read_command_file(filename);
}


void Xmgrace::init(const std::string& parameter_file)
{
  if ( parameter_file == ""){ // no parameter file 
    if(GraceOpen(GRACEBUFFER)==-1){
      std::cerr << "Can't run Grace." << std::endl;
      exit(-1);
    }
  } else {
    if( GraceOpenVA("xmgrace",GRACEBUFFER , "-nosafe", "-noask","-param", 
		    parameter_file.c_str(), NULL) == -1 ){
      std::cerr << "Can't run Grace.(" << parameter_file << ")" << std::endl;
      exit(-1);
    }
  }
  
  GracePrintf("focus off");
}

//void XmgraceGraph::endl()
//{
//  newline = true;
//}


//void Xmgrace::endl(XmgraceGraph& graph)
//{
//  graph.endl();
//}


//void endl(XmgraceGraph& graph)
//{
//  graph.newline = true;
//  graph.endl();
//}