#include <iostream>
#include <memory>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

#include "../shared/ThreadMonitor.h"

#include "NfsHelper.h"


namespace NfsHelper
{
  // Pointer containing an error message
  std::unique_ptr<std::string> strerror {new std::string};

  std::string pathForFile(int64_t idNumber)
  {
    if (idNumber <= 0)
      return ""; // This should never happen.
    const int remainder = idNumber % DIVISOR;
    // The number 19 would go into bin 1 because 19 / 9 gives a remainer of 1.
    // So the path would be "layouts/9/1/19".  Note that the divisor is part of
    // the path.  Currently that's hard coded, but what if we need to change
    // that from 9 to 16 at some point?  We probably don't want to recreate
    // this entire directory structure while the server is running.  The new
    // path would be "layouts/16/3/19".  We'd only use the new path for
    // writing.  We'd possibly check both paths for reading or deleting.
    std::string result = "layouts/";
    result += ntoa(DIVISOR);
    result += '/';
    result += ntoa(remainder);
    result += '/';
    result += ntoa(idNumber);
    return result;
  };

  static const std::string s_saveToDisk = "saveToDisk";
  TclList saveToDisk(int64_t channelId, std::string const &toSave)
  {
    ThreadMonitor::SetState tm(s_saveToDisk);
    tm.increment(s_saveToDisk);
    const std::string finalFileName = pathForFile(channelId);
    if (finalFileName.empty())
      return TclList()<<FLF<<"INVALID STRATEGY ID";
    const std::string tempFileName = finalFileName + ".temp";
    int handle = creat(tempFileName.c_str(), PERMISSIONS);
    if (handle <= 0){
      *strerror = "System failure: unable to create file:  " + tempFileName;
      std::cout<< *strerror <<std::endl;
      return TclList()<<FLF<< *strerror;
    }

    size_t written = write(handle, toSave.c_str(), toSave.size());
    if (written != toSave.size())
    {
      TclList msg;
      msg<<FLF<<"PROBLEM IN write()"<<tempFileName<<toSave.size()<<written;
      if (((ssize_t)written) < 0){
        *strerror = "System failure: unable to write data in file:  " + tempFileName;
        std::cout<< *strerror <<std::endl;
        msg<< *strerror;
      }
      return msg;
    }
    int closeError = close(handle);
    if (closeError)
      // This is possible.  According to the man page, close might report
      // an error because of a previous call to write().  This is
      // especially common with NFS.
      // TODO https://linux.die.net/man/3/explain_close
      // Or maybe not.  As the man page for close explains, as soon as you call
      // close() on a file descriptor, even if close() returns an error,
      // another thread might reuse the file descriptor.
      return TclList()<<FLF<<"CAN'T close() FILE"<<tempFileName<<toSave.size()
                      <<errorString();
    int renameError = rename(tempFileName.c_str(), finalFileName.c_str());
    if (renameError){
      *strerror = "System failure: unable to rename file:  " + tempFileName;
      std::cout<< *strerror <<std::endl;
      return TclList()<<FLF<<"CAN'T rename() FILE"<< *strerror;
    }
    // Success!
    return TclList();
  }



}