// GssCredentialManager.cxx

#include "dataset_credential/GssCredentialManager.h"
#include <iostream>
#include <map>
#include "dataset_util/PThreadMutex.h"
#include "dataset_util/ThreadCredential.h"
#include "gsoap/dial_soap.h"
#include "dataset_credential/CredentialSelectionCatalog.h"

using std::string;
using std::map;
using std::cerr;
using std::endl;
using dset::GssCredential;
using dset::GssCredentialManager;
using dset::CredentialSelectionCatalog;

typedef GssCredential::Name Name;
typedef map<Name, GssCredential*> CredMap;
typedef ThreadCredential::NameMap NameMap;

//**********************************************************************
// Local definitions.

namespace {

PThreadMutex& mutex() {
  static PThreadMutex obj;
  return obj;
}

// Return the map of credentials indexed by thread.
CredMap& credmap() {
  static CredMap obj;
  return obj;
}

} // end unnamed namespace

//**********************************************************************
// Member functions.
//**********************************************************************

// Insert credential.

int GssCredentialManager::insert(const GssCredential& cred) {
  int rstat = 0;
  mutex().lock();
  Name name = cred.name();
  int remstat = remove(name);
  if ( remstat == 0 ) {
    GssCredential* pcred = new GssCredential(cred, true);
    if ( pcred->is_valid() ) {
      credmap()[name] = pcred;
    } else {
      delete pcred;
      rstat = 1;
    }
  } else {
    rstat = 10 + remstat;
  }
  mutex().unlock();
  return rstat;
}

//**********************************************************************

// Remove credential.

int GssCredentialManager::remove(Name name) {
  int rstat = 0;
  mutex().lock();
  CredMap::iterator icre = credmap().find(name);
  if ( icre != credmap().end() ) {
    GssCredential* pcred = icre->second;
    delete pcred;
    credmap().erase(icre);
  }
  mutex().unlock();
  return rstat;
}

//**********************************************************************

// Number of credentials.

int GssCredentialManager::size() {
  return credmap().size();
}

//**********************************************************************

// Get a credential.

GssCredential* GssCredentialManager::get(Name name) {
  mutex().lock();
  CredMap::const_iterator icre = credmap().find(name);
  GssCredential* pcred = 0;
  if ( icre != credmap().end() ) {
    pcred = icre->second;
  }
  mutex().unlock();
  return pcred;
}

//**********************************************************************

// Acquire the default credential and set it as the current value
// for this thread.

int GssCredentialManager::set_default() {
  GssCredential cred;
  if ( ! cred.is_valid() ) {
    return 1;
  }
  int iacq = GssCredentialManager::insert(cred);
  if ( iacq ) {
    return 2;
  }
  int iset = GssCredentialManager::set_name(cred.name());
  if ( iset ) {
    return 3;
  }
  return 0;
}

//**********************************************************************

// Set name.

int GssCredentialManager::set_name(Name name) {
  ThreadCredential tc;
  pthread_t th = pthread_self();
  mutex().lock();
  tc.names()[th] = name;
  mutex().unlock();
  return 0;
}

//**********************************************************************

// Unset name.

int GssCredentialManager::unset_name() {
  ThreadCredential tc;
  pthread_t th = pthread_self();
  mutex().lock();
  NameMap::iterator inam = tc.names().find(th);
  if ( inam != tc.names().end() ) {
    tc.names().erase(inam);
  }
  mutex().unlock();
  return 0;
}

//**********************************************************************

// Fetch name.

Name GssCredentialManager::name() {
  ThreadCredential tc;
  Name name;
  pthread_t th = pthread_self();
  mutex().lock();
  NameMap::iterator inam = tc.names().find(th);
  if ( inam != tc.names().end() ) {
    name = inam->second;
  }
  mutex().unlock();
  return name;
}

//**********************************************************************

// Set owner.

int GssCredentialManager::set_owner(Name owner) {
  CredentialSelectionCatalog& csc =
    CredentialSelectionCatalog::default_instance();
  int istat = csc.insert(name(), owner);
  if ( istat != 0 ) {
    cerr << "GssCredentialManager::set_owner: "
         << "CSC insertion failed with error " << istat << endl;
    cerr << "  " << csc.error_message() << endl;
  }
  return istat;
}

//**********************************************************************

// Fetch owner.

Name GssCredentialManager::owner() {
  CredentialSelectionCatalog& csc =
    CredentialSelectionCatalog::default_instance();
  Name owner = csc.owner(name());
  return owner;
}

//**********************************************************************

// Fetch credential.

GssCredential* GssCredentialManager::credential() {
  GssCredential* pcred = 0;
  mutex().lock();
  Name nam = name();
  if ( nam.size() ) {
    pcred = get(nam);
  }
  mutex().unlock();
  return pcred;
}

//**********************************************************************