/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * Author: pgess <v.melnychenko@xreate.org>
 *
 * containers.cpp
 * Created on 3/14/15.
 */

/**
 * \file    query/containers.h
 * \brief   Represents reasoner's solution on [Container implementations](/w/concepts/containers)
 */

#include <transcendlayer.h>
#include "query/containers.h"

using namespace std;
using namespace xreate::containers;
using namespace xreate;

Implementation
Query::queryImplementation(xreate::Symbol const &s) {
  if (Attachments::exists<Implementation>(s)) {
    return Attachments::get<Implementation>(s);
  }

  return  Implementation::create(s);
}

Query::Query() {
  Attachments::init<Implementation>();
}

void
Query::init(TranscendLayer* transcend) {
  if (flagDataIsLoaded) return;

  //Fill implementation data for a data sources:
  auto range = transcend->query(Config::get("containers.id.implementations"));
  if (range.size())
    for(auto atom : range) {
      auto data = TranscendLayer::parse<SymbolPacked, Gringo::Symbol>(atom.second);

      Symbol var  = transcend->unpack(get<0>(data));
      string implStr  = get<1>(data).name().c_str();

      if (implStr == Config::get("containers.impl.solid")) {
        auto size = TranscendLayer::parse<int>(get<1>(data));
        Attachments::put<Implementation>(var,{SOLID, ImplementationRec<SOLID>
          {get<0>(size)}});

      } else if (implStr == Config::get("containers.impl.onthefly")) {
        Attachments::put<Implementation>(var,{ON_THE_FLY, ImplementationRec<ON_THE_FLY>
          {var}});

      } else {
        assert(false && "Unable to determine proper implementation for the symbol");
      }
    }

  flagDataIsLoaded = true;
}

Implementation
Implementation::create(const Symbol &var) {
  //TODO review implementation determination strategy
  Expression varDecl = CodeScope::getDefinition(var);
  switch (varDecl.op) {
  case Operator::LIST_RANGE:
  {
    ImplementationRec<ON_THE_FLY> rec{var};
    return {ON_THE_FLY, rec};
  }

  case Operator::LIST:
  {
    return {SOLID, ImplementationRec<SOLID> {varDecl.getOperands().size()}};
  }

  default: break;
  };

  ImplementationLinkedList ill(var);
  if (ill) {
    return ill.getImplementationData();
  }

  assert(false && "Unable to determine proper implementation for the symbol");
  return Implementation();
}

ImplementationLinkedList::ImplementationLinkedList(const Symbol& source)
:    flagIsValid(false), s(source) {

  const Expression& sourceExpr = CodeScope::getDefinition(source);

  if (sourceExpr.tags.count(Config::get("containers.id.linkedlist"))) {
    flagIsValid = true;

    Expression tagLinkedlist = sourceExpr.tags.at(Config::get("containers.id.linkedlist"));
    assert(tagLinkedlist.operands.size() == 2);
    fieldPointer = tagLinkedlist.operands.at(0).getValueString();
    terminator = tagLinkedlist.operands.at(1);
  }
}

ImplementationLinkedList::operator bool () const {
  return flagIsValid;
}

Implementation
ImplementationLinkedList::getImplementationData() const {
  return {ON_THE_FLY, ImplementationRec<ON_THE_FLY>{s}};
}