#include <sstream>
#include <string>

#include "IDigitProxy.hxx"
#include "IDigitManager.hxx"
#include "IOADatabase.hxx"

ClassImp(COMET::IDigitProxy);

COMET::IDigitProxy::~IDigitProxy() {}

COMET::IDigitProxy::IDigitProxy() 
  : fDigitSignature(0), fDigit(NULL), fContainer(NULL) {}

COMET::IDigitProxy::IDigitProxy(const COMET::IDigitContainer& container,
                             unsigned int offset) 
    : fDigitSignature(0), fDigit(NULL), fContainer(NULL) {

    int type = IDigitProxy::ConvertName(container.GetName());
    SetProxyType(type);
    if (container.size() <= offset) throw EDigitNotFound();
    COMET::IDigit* digit = container[offset];
    unsigned int cid = digit->GetChannelId().AsUInt();
    unsigned int salt = container.GetSignature()+cid;
    SetProxySalt(salt);
    SetProxyOffset(offset);
    SetProxyCache(digit,NULL);
}

COMET::IDigitProxy::IDigitProxy(const COMET::IDigitContainer& container,
                             const COMET::IDigitContainer::iterator index) 
    : fDigitSignature(0), fDigit(NULL), fContainer(NULL) {

    int type = IDigitProxy::ConvertName(container.GetName());
    SetProxyType(type);
    int offset = index-container.begin();
    if (offset<0 || container.size()<=(unsigned)offset) throw EDigitNotFound();
    COMET::IDigit* digit = container[offset];
    unsigned int cid = digit->GetChannelId().AsUInt();
    unsigned int salt = container.GetSignature()+cid;
    SetProxySalt(salt);
    SetProxyOffset(offset);
    SetProxyCache(digit,NULL);
}

COMET::IDigitProxy::IDigitProxy(int proxy) 
    : fDigitSignature(proxy), fDigit(NULL), fContainer(NULL) {}

COMET::IDigit* COMET::IDigitProxy::operator*() const {
    return COMET::IOADatabase::Get().Digits().GetDigit(*this);
}

COMET::IDigitContainer& COMET::IDigitProxy::GetContainer() const {
    COMET::IOADatabase::Get().Digits().GetDigit(*this);
    return *fContainer;
}

enum COMET::IDigitProxy::ProxyType COMET::IDigitProxy::ConvertName(std::string name) {
    if (name == "p0d") return kP0D;
    if (name == "tpc") return kTPC;
    if (name == "fgd") return kFGD;
    if (name == "ecal") return kECal;
    if (name == "smrd") return kSMRD;
    if (name == "ingrid") return kINGRID;
    if (name == "test") return kTest;
    return kInvalid;
}

std::string COMET::IDigitProxy::ConvertType(int type) {
    std::string name;

    // Find the name of the IDigitContainer based on the proxy type.
    switch (type) {
    case kTest: name = "test"; break;
    case kP0D: name = "p0d"; break;
    case kTPC: name = "tpc"; break;
    case kFGD: name = "fgd"; break;
    case kECal: name = "ecal"; break;
    case kSMRD: name = "smrd"; break;
    case kINGRID: name = "ingrid"; break;
    case kInvalid: name = "invalid"; break;
    default:
        throw EDigitTypeInvalid();
    }

    return name;
}

bool COMET::IDigitProxy::CheckSalt(unsigned int signature,
                                const COMET::IDigit* digit) const {
    unsigned int trial = (signature + digit->GetChannelId().AsUInt())%1024;
    return trial == GetProxySalt();
}

enum COMET::IDigitProxy::ProxyType COMET::IDigitProxy::GetProxyType() const {
    unsigned sig = (fDigitSignature & 0xF8000000u) >> 27;
    return (COMET::IDigitProxy::ProxyType) sig;
}

unsigned int COMET::IDigitProxy::GetProxySalt() const {
    unsigned int salt = (fDigitSignature & 0x07FE0000u) >> 17;
    return salt;
}

unsigned int COMET::IDigitProxy::GetProxyOffset() const {
    unsigned int offset = (fDigitSignature & 0x0001FFFF);
    return offset;
}

COMET::IDigit* COMET::IDigitProxy::GetProxyCache() const {
    return fDigit;
}

void COMET::IDigitProxy::SetProxyCache(IDigit* digit,
                                    IDigitContainer* container) const {
    fDigit = digit;
    fContainer = container;
}

void COMET::IDigitProxy::SetProxyType(int type) {
    fDigitSignature = (fDigitSignature & 0x07FFFFFFu)|((type & 0x001Fu) << 27);
}

void COMET::IDigitProxy::SetProxySalt(int salt) {
    fDigitSignature = (fDigitSignature & 0xF801FFFFu)|((salt & 0x03FFu) << 17);
}

void COMET::IDigitProxy::SetProxyOffset(int off) {
    if (off & 0xFFFE0000u) off = 0x1FFFFu;
    if (off == 0x1FFFFu) COMETSevere("Invalid proxy has been created.");
    fDigitSignature = (fDigitSignature & 0xFFFE0000u) | (off & 0x1FFFFu);
}

bool COMET::IDigitProxy::IsValid() const {
    if (GetProxyOffset() == 0x1FFFFu) return false;
    if (GetProxyType() == kTest) return true;
    if (GetProxyType() == kP0D) return true;
    if (GetProxyType() == kTPC) return true;
    if (GetProxyType() == kFGD) return true;
    if (GetProxyType() == kECal) return true;
    if (GetProxyType() == kSMRD) return true;
    if (GetProxyType() == kINGRID) return true;
    return false;
}

std::string COMET::IDigitProxy::AsString() const {
    std::ostringstream out;
    try {
        out << ConvertType(GetProxyType()) << ":";
    }
    catch (...) {
        out << "invalid:";
    }
    unsigned int offset = GetProxyOffset();
    if (offset == 0x1FFFFu) out << " invalid offset";
    else out << " " << offset;
    return out.str();
}

bool COMET::IDigitProxy::operator == (const COMET::IDigitProxy& rhs) const {
    return fDigitSignature == rhs.fDigitSignature;
}