#include "comdelgenerator.h"

#include<set>

namespace domain {

Component::ComponentType toType(ComponentNode::ComponentType type) {
    if(type == ComponentNode::MEMORY) {
        return Component::MEMORY;
    } else if(type == ComponentNode::PROCESSOR) {
        return Component::PROCESSOR;
    }
    return Component::OTHER;
}

Action::ActionType toType(ActionNode::ActionType type) {
    if(type == ActionNode::ERROR) {
        return Action::ERROR;
    }
    return Action::WARNING;
}

Value::ValueType toType(ValueNode::ValueType type) {
    switch (type) {
    case ValueNode::BOOL:
        return Value::BOOL;
    case ValueNode::WIRE:
        return Value::WIRE_REFERENCE;
    case ValueNode::STRING:
        return Value::STRING;
    case ValueNode::INT:
        return Value::INT;
    default:
        return Value::UNDEFINED;
    }
}


Value toType(ValueNode node) {
    if(node.getType() == ValueNode::BOOL) {
        return Value::fromBool(node.asBool());
    } else if(node.getType() == ValueNode::INT) {
        return Value::fromInt(node.asInt());
    } else if(node.getType() == ValueNode::STRING) {
        return Value::fromString(node.asString());
    }
    return Value::fromReference(node.asIdentifier(), Value::UNDEFINED);
}


Bus::BusType toType(BusNode::BusType type) {
    if(type == BusNode::AUTOMATIC) {
        return Bus::AUTOMATIC;
    }
    return Bus::REGULAR;
}


Pin::PinType toType(PinNode::PinType type) {
    if(type == PinNode::IN) {
        return Pin::IN;
    } else if(type == PinNode::OUT) {
        return Pin::OUT;
    }
    return Pin::IN_OUT;
}

PinConnection::ConnectionType toType(PinConnectionNode::ConnectionType type)
{
    if(type == PinConnectionNode::AUTOMATICALLY) {
        return PinConnection::AUTOMATICALLY;
    }
    return PinConnection::CHECK_ONLY;
}


Popup::PopupType toType(PopupNode::PopupType type)
{
    if(type == PopupNode::AUTOMATIC) {
        return Popup::AUTOMATIC;
    }
    return Popup::ON_DEMAND;
}

ComdelGenerator::ComdelGenerator(std::vector<FunctionSignature> signatures)
    : signatures(signatures)
{}

std::optional<Library> ComdelGenerator::loadLibrary(LibraryNode node, ParseContext* parseContext, std::ostream& stream)
{
    // library fields
    if(!node.name) {
        errors.push_back(SourceError{node.span, "missing @name"});
        return nullopt;
    }
    std::string name = node.name->asString();

    if(!node.componentDirectory) {
        errors.push_back(SourceError{node.span, "missing @componentDirectory"});
        return nullopt;
    }
    std::string componentDirectory = node.componentDirectory->asString();

    std::string header = node.header ? node.header->asString() : "";

    std::string libraryInfo = node.libraryInfo ? node.libraryInfo->asString() : "";

    std::vector<AddressSpace> addressSpaces;
    for(auto& as: node.addressSpaces) {
        addressSpaces.push_back(*loadAddressSpace(as));
    }

    std::vector<Component> components;
    for(auto& comp: node.components) {
        std::optional<Component> component;
        component = loadComponent(comp);
        if(component) {
            components.push_back(*component);
        }
    }

    std::vector<Connection> connections;
    for(uint i=0; i<node.connections.size(); i++) {
        auto conn = loadConnection(node.connections[i]);
        if(!conn) {
            return nullopt;
        }
        connections.push_back(*conn);
    }

    std::map<std::string, std::string> messages;
    for(uint i=0; i<node.messages.size(); i++) {
        if(!node.messages[i].value.is(ValueNode::STRING)) {
            errors.push_back(SourceError{node.messages[i].key.span, "expected `string`"});
            return nullopt;
        }
        messages[node.messages[i].key.value] = node.messages[i].value.asString();
    }

    std::vector<Bus> buses;
    for(uint i=0; i<node.buses.size(); i++) {
        auto bus = loadBus(node.buses[i]);
        if(!bus) {
            return nullopt;
        }
    }

    return Library(name, libraryInfo, header, componentDirectory, addressSpaces, components, buses, connections, messages);
}

std::optional<Bus> ComdelGenerator::loadBus(BusNode node)
{
    std::string name = node.name.value;

    auto count = std::make_pair<int, int>(1, 1);
    if(node.count) {
        count = std::make_pair<int, int>(node.count->first.value, node.count->second.value);
    }
    if(count.first > count.second || count.first < 0) {
        errors.push_back(SourceError{node.count->span, "invalid @size (min, max) := min <= max && min >= 0"});
        return nullopt;
    }

    auto type = toType(node.type);

    if(!node.tooltip && type == Bus::REGULAR) {
        errors.push_back(SourceError{node.span, "missing @tooltip"});
        return nullopt;
    }
    std::string tooltip = node.tooltip->asString();

    if(!node.display && type == Bus::REGULAR) {
        errors.push_back(SourceError{node.span, "missing @display"});
        return nullopt;
    }
    if(node.display && type == Bus::AUTOMATIC) {
        errors.push_back(SourceError{node.span, "automatic bus cannot have a @display"});
        return nullopt;
    }


    optional<Display> display;
    if(Bus::REGULAR) {
        display = loadDisplay(*node.display);
        if(!display) {
            return nullopt;
        }
    }

    return Bus(name, tooltip, type, count, display);
}


std::optional<AddressSpace> ComdelGenerator::loadAddressSpace(AddressSpaceNode node)
{
    return AddressSpace(node.name.value, node.start.value, node.end.value);
}

std::optional<Connection> ComdelGenerator::loadConnection(ConnectionNode node)
{
    std::string component = node.component.value;
    std::string pin = node.pin.value;
    std::string bus = node.bus.value;

    std::vector<Attribute> attributes;
    for(uint i=0; i<node.attributes.size(); i++) {
        auto attr = loadAttribute(node.attributes[i]);
        if(!attr) {
            return nullopt;
        }
        attributes.push_back(*attr);
    }

    std::set<std::string> attributeNames;
    for(auto attribute: attributes) {
        attributeNames.insert(attribute.getName());
    }

    std::vector<Value> wires;
    for(uint i=0; i<node.wires.size(); i++) {
        if(attributeNames.count(node.wires[i].value)) {
            wires.push_back(Value::fromReference(node.wires[i].value, Value::ATTRIBUTE_REFERENCE));
        } else {
            wires.push_back(Value::fromReference(node.wires[i].value, Value::WIRE_REFERENCE));
        }
    }

    return Connection(component, pin, bus, attributes, wires);
}

std::optional<Component> ComdelGenerator::loadComponent(ComponentNode node)
{
    std::string name = node.name.value;

    if(!node.tooltip) {
        errors.push_back(SourceError{node.span, "missing @tooltip"});
        return nullopt;
    }
    std::string tooltip = node.tooltip->asString();

    if(!node.source) {
        errors.push_back(SourceError{node.span, "missing @source"});
        return nullopt;
    }
    std::string source = node.source->asString();

    Component::ComponentType type = toType(node.type);

    std::vector<Attribute> attributes;
    for(auto& a: node.attributes) {
        std::optional<Attribute> attribute = loadAttribute(a);
        if(attribute) {
            attributes.push_back(*attribute);
        }
    }

    std::vector<Rule> rules;
    for(auto& r: node.rules) {
        std::optional<Rule> rule = loadRule(r);
        if(rule) {
            rules.push_back(*rule);
        }
    }

    if(!node.instanceName) {
        errors.push_back(SourceError{node.span, "missing @instanceName"});
        return nullopt;
    }
    std::string instanceName = node.instanceName->asString();

    auto count = std::make_pair<int, int>(1, 1);
    if(node.count) {
        count = std::make_pair<int, int>(node.count->first.value, node.count->second.value);
    }
    if(count.first > count.second || count.first < 0) {
        errors.push_back(SourceError{node.count->first.span, "invalid @size"});
        return nullopt;
    }

    if(!node.display) {
        errors.push_back(SourceError{node.span, "missing @display"});
        return nullopt;
    }
    optional<Display> display = loadDisplay(*node.display);
    if(!display) {
        return nullopt;
    }

    std::vector<Pin> pins;
    for(uint i=0; i<node.pins.size(); i++) {
        auto pin = loadPin(node.pins[i]);
        if(!pin) {
            return nullopt;
        }
    }

    return Component(name, tooltip, source, type, rules, instanceName, count, *display, pins, attributes);
}

optional<Pin> ComdelGenerator::loadPin(PinNode node)
{
    std::string name = node.name.value;
    Pin::PinType type = toType(node.type);

    if(!node.tooltip) {
        errors.push_back(SourceError{node.span, "missing @tooltip"});
        return nullopt;
    }
    std::string tooltip = node.tooltip->asString();

    if(!node.display) {
        errors.push_back(SourceError{node.span, "missing @display"});
        return nullopt;
    }
    std::vector<Attribute> attributes;
    optional<Display> display = loadDisplay(*node.display);
    if(!display) {
        return nullopt;
    }

    if(!node.connection) {
        errors.push_back(SourceError{node.span, "missing @connection"});
        return nullopt;
    }
    auto connection = loadPinConnection(*node.connection);

    return Pin(name, type, tooltip, connection, *display);
}


std::optional<Display> ComdelGenerator::loadDisplay(DisplayNode node)
{
    return Display();
}


PinConnection ComdelGenerator::loadPinConnection(PinConnectionNode node)
{
    std::string message = node.message.asString();
    PinConnection::ConnectionType type = toType(node.type);
    return PinConnection(message, type);
}

std::optional<Attribute> ComdelGenerator::loadAttribute(AttributeNode node)
{
    std::string name = node.name.value;
    Value value;
    if(node.type == ValueNode::INT) {
        value = Value::fromInt(node.defaultValue->asInt());
    } else if (node.type == ValueNode::BOOL) {
        value = Value::fromBool(node.defaultValue->asBool());
    } else if (node.type == ValueNode::STRING) {
        value = Value::fromString(node.defaultValue->asString());
    } else if (node.type == ValueNode::WIRE) {
        value = Value::fromReference(node.defaultValue->asIdentifier(), Value::WIRE_REFERENCE);
    }

    std::optional<Popup> popup;
    if(node.popup) {
        popup = loadPopup(*node.popup, name, value.getType());
    }

    return Attribute(name, value, popup);
}

std::optional<Popup> ComdelGenerator::loadPopup(PopupNode node, std::string name, Value::ValueType type)
{
    auto popupType = toType(*node.type);

    if(!node.title) {
        errors.push_back(SourceError{node.span, "missing @title"});
        return nullopt;
    }
    std::string title = node.title->asString();

    if(!node.text) {
        errors.push_back(SourceError{node.span, "missing @text"});
        return nullopt;
    }
    std::string text = node.text->asString();

    std::vector<Attribute> attributes;
    attributes.push_back(Attribute(name, Value::ofType(type)));

    std::vector<Rule> rules;
    for(auto& r: node.rules) {
        std::optional<Rule> rule = loadRule(r);
        if(rule) {
            rules.push_back(*rule);
        }
    }

    std::vector<Enumeration> enumeration;
    if(node.enumerated) {
        for(uint i=0; i<node.enumeration.size(); i++) {
            if(toType(node.enumeration[i].value.getType()) != type) {
                errors.push_back(SourceError{node.enumeration[i].span, "wrong type"});
                return nullopt;
            }
            enumeration.push_back(Enumeration(node.enumeration[i].key.asString(),
                                              toType(node.enumeration[i].value)));
        }
    }

    return Popup(title, text, popupType, rules, enumeration);
}

std::optional<Rule> ComdelGenerator::loadRule(RuleNode node)
{
    std::vector<IfStatement> statements;

    for(auto& stmt: node.statements) {
        auto condition = loadCondition(stmt.condition);
        if(condition) {
            statements.push_back(IfStatement(*condition, Action(toType(stmt.action.type), stmt.action.message.asString())));
        } else {
            return nullopt;
        }
    }

    return Rule(statements);
}

std::optional<Condition> ComdelGenerator::loadCondition(ConditionNode node)
{
    std::string function = node.functionName.value;

    for(uint i=0; i<signatures.size(); i++) {
        if(signatures[i].name == function) {
            if(signatures[i].params.size() == node.params.size()) {
                std::vector<Value> params;
                for(int j=0; j<signatures[i].params[i]; j++) {
                    params.push_back(toType(node.params[i]));
                }
                return Condition(function,params, node.negated);
            }
        }
    }

    return nullopt;
}



} // namespace domain