/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.olingo.server.core.uri.parser;

import java.util.Collection;
import java.util.Map;

import org.apache.olingo.commons.api.edm.Edm;
import org.apache.olingo.commons.api.edm.EdmNavigationProperty;
import org.apache.olingo.commons.api.edm.EdmProperty;
import org.apache.olingo.commons.api.edm.EdmStructuredType;
import org.apache.olingo.commons.api.edm.constants.EdmTypeKind;
import org.apache.olingo.commons.api.ex.ODataRuntimeException;
import org.apache.olingo.server.api.OData;
import org.apache.olingo.server.api.uri.UriInfoKind;
import org.apache.olingo.server.api.uri.UriResourceNavigation;
import org.apache.olingo.server.api.uri.UriResourcePartTyped;
import org.apache.olingo.server.api.uri.queryoption.AliasQueryOption;
import org.apache.olingo.server.api.uri.queryoption.ExpandItem;
import org.apache.olingo.server.api.uri.queryoption.ExpandOption;
import org.apache.olingo.server.api.uri.queryoption.LevelsExpandOption;
import org.apache.olingo.server.api.uri.queryoption.SystemQueryOption;
import org.apache.olingo.server.api.uri.queryoption.SystemQueryOptionKind;
import org.apache.olingo.server.core.uri.UriInfoImpl;
import org.apache.olingo.server.core.uri.UriResourceComplexPropertyImpl;
import org.apache.olingo.server.core.uri.UriResourceCountImpl;
import org.apache.olingo.server.core.uri.UriResourceEntitySetImpl;
import org.apache.olingo.server.core.uri.UriResourceNavigationPropertyImpl;
import org.apache.olingo.server.core.uri.UriResourceRefImpl;
import org.apache.olingo.server.core.uri.parser.UriTokenizer.TokenKind;
import org.apache.olingo.server.core.uri.queryoption.CountOptionImpl;
import org.apache.olingo.server.core.uri.queryoption.ExpandItemImpl;
import org.apache.olingo.server.core.uri.queryoption.ExpandOptionImpl;
import org.apache.olingo.server.core.uri.queryoption.LevelsOptionImpl;
import org.apache.olingo.server.core.uri.queryoption.SkipOptionImpl;
import org.apache.olingo.server.core.uri.queryoption.TopOptionImpl;
import org.apache.olingo.server.core.uri.validator.UriValidationException;

public class ExpandParser {

  private final Edm edm;
  private final OData odata;
  private final Map<String, AliasQueryOption> aliases;
  private final Collection<String> crossjoinEntitySetNames;

  public ExpandParser(final Edm edm, final OData odata, final Map<String, AliasQueryOption> aliases,
      final Collection<String> crossjoinEntitySetNames) {
    this.edm = edm;
    this.odata = odata;
    this.aliases = aliases;
    this.crossjoinEntitySetNames = crossjoinEntitySetNames;
  }

  public ExpandOption parse(UriTokenizer tokenizer, final EdmStructuredType referencedType)
      throws UriParserException, UriValidationException {
    ExpandOptionImpl expandOption = new ExpandOptionImpl();
    do {
      // In the crossjoin case the start has to be an EntitySet name which will dictate the reference type
      if (crossjoinEntitySetNames != null && !crossjoinEntitySetNames.isEmpty()) {
        final ExpandItem item = parseCrossJoinItem(tokenizer);
        expandOption.addExpandItem(item);
      } else {
        final ExpandItem item = parseItem(tokenizer, referencedType);
        expandOption.addExpandItem(item);
      }
    } while (tokenizer.next(TokenKind.COMMA));

    return expandOption;
  }

  private ExpandItem parseCrossJoinItem(UriTokenizer tokenizer) throws UriParserSemanticException {
    ExpandItemImpl item = new ExpandItemImpl();
    if (tokenizer.next(TokenKind.STAR)) {
      item.setIsStar(true);
    } else if (tokenizer.next(TokenKind.ODataIdentifier)) {
      String entitySetName = tokenizer.getText();
      if (crossjoinEntitySetNames.contains(entitySetName)) {
        UriInfoImpl resource = new UriInfoImpl().setKind(UriInfoKind.resource);
        final UriResourceEntitySetImpl entitySetResourceSegment =
            new UriResourceEntitySetImpl(edm.getEntityContainer().getEntitySet(entitySetName));
        resource.addResourcePart(entitySetResourceSegment);

        item.setResourcePath(resource);
      } else {
        throw new UriParserSemanticException("Unknown crossjoin entity set.",
            UriParserSemanticException.MessageKeys.UNKNOWN_PART, entitySetName);
      }
    } else {
      throw new UriParserSemanticException("If the target resource is a crossjoin an entity set is "
          + "needed as the starting point.",
          UriParserSemanticException.MessageKeys.UNKNOWN_PART);
    }
    return item;
  }

  private ExpandItem parseItem(UriTokenizer tokenizer, final EdmStructuredType referencedType)
      throws UriParserException, UriValidationException {
    ExpandItemImpl item = new ExpandItemImpl();
    if (tokenizer.next(TokenKind.STAR)) {
      item.setIsStar(true);
      if (tokenizer.next(TokenKind.SLASH)) {
        ParserHelper.requireNext(tokenizer, TokenKind.REF);
        item.setIsRef(true);
      } else if (tokenizer.next(TokenKind.OPEN)) {
        ParserHelper.requireNext(tokenizer, TokenKind.LEVELS);
        ParserHelper.requireNext(tokenizer, TokenKind.EQ);
        item.setSystemQueryOption((SystemQueryOption) parseLevels(tokenizer));
        ParserHelper.requireNext(tokenizer, TokenKind.CLOSE);
      }

    } else {
      final EdmStructuredType typeCast = ParserHelper.parseTypeCast(tokenizer, edm, referencedType);
      if (typeCast != null) {
        item.setTypeFilter(typeCast);
        ParserHelper.requireNext(tokenizer, TokenKind.SLASH);
      }

      UriInfoImpl resource = parseExpandPath(tokenizer, edm, referencedType, item);

      UriResourcePartTyped lastPart = (UriResourcePartTyped) resource.getLastResourcePart();

      boolean hasSlash = false;
      EdmStructuredType typeCastSuffix = null;
      if (tokenizer.next(TokenKind.SLASH)) {
        hasSlash = true;
        if (lastPart instanceof UriResourceNavigation) {
          UriResourceNavigationPropertyImpl navigationResource = (UriResourceNavigationPropertyImpl) lastPart;
          final EdmNavigationProperty navigationProperty = navigationResource.getProperty();
          typeCastSuffix = ParserHelper.parseTypeCast(tokenizer, edm, navigationProperty.getType());
          if (typeCastSuffix != null) {
            if (navigationProperty.isCollection()) {
              navigationResource.setCollectionTypeFilter(typeCastSuffix);
            } else {
              navigationResource.setEntryTypeFilter(typeCastSuffix);
            }
            hasSlash = false;
          }
        }
      }

      final EdmStructuredType newReferencedType = typeCastSuffix != null ? typeCastSuffix 
        : (EdmStructuredType) lastPart.getType();
      final boolean newReferencedIsCollection = lastPart.isCollection();
      if (hasSlash || tokenizer.next(TokenKind.SLASH)) {
        if (tokenizer.next(TokenKind.REF)) {
          resource.addResourcePart(new UriResourceRefImpl());
          item.setIsRef(true);
          parseOptions(tokenizer, newReferencedType, newReferencedIsCollection, item, true, false);
        } else {
          ParserHelper.requireNext(tokenizer, TokenKind.COUNT);
          resource.addResourcePart(new UriResourceCountImpl());
          item.setCountPath(true);
          parseOptions(tokenizer, newReferencedType, newReferencedIsCollection, item, false, true);
        }
      } else {
        parseOptions(tokenizer, newReferencedType, newReferencedIsCollection, item, false, false);
      }

      item.setResourcePath(resource);
    }

    return item;
  }

  protected static UriInfoImpl parseExpandPath(UriTokenizer tokenizer, final Edm edm,
      final EdmStructuredType referencedType, ExpandItemImpl item) throws UriParserException {
    UriInfoImpl resource = new UriInfoImpl().setKind(UriInfoKind.resource);

    EdmStructuredType type = referencedType;
    String name = null;
    while (tokenizer.next(TokenKind.ODataIdentifier)) {
      name = tokenizer.getText();
      final EdmProperty property = referencedType.getStructuralProperty(name);
      if (property != null && property.getType().getKind() == EdmTypeKind.COMPLEX) {
        type = (EdmStructuredType) property.getType();
        UriResourceComplexPropertyImpl complexResource = new UriResourceComplexPropertyImpl(property);
        ParserHelper.requireNext(tokenizer, TokenKind.SLASH);
        final EdmStructuredType typeCast = ParserHelper.parseTypeCast(tokenizer, edm, type);
        if (typeCast != null) {
          complexResource.setTypeFilter(typeCast);
          ParserHelper.requireNext(tokenizer, TokenKind.SLASH);
          type = typeCast;
        }
        resource.addResourcePart(complexResource);
      }
    }

    final EdmNavigationProperty navigationProperty = type.getNavigationProperty(name);
    if (navigationProperty == null) {
      if (tokenizer.next(TokenKind.STAR)) {
        item.setIsStar(true);
      } else {
        throw new UriParserSemanticException(
            "Navigation Property '" + name + "' not found in type '" + type.getFullQualifiedName() + "'.",
            UriParserSemanticException.MessageKeys.EXPRESSION_PROPERTY_NOT_IN_TYPE, type.getName(), name);
      }
    } else {
      resource.addResourcePart(new UriResourceNavigationPropertyImpl(navigationProperty));
    }

    return resource;
  }

  private void parseOptions(UriTokenizer tokenizer,
      final EdmStructuredType referencedType, final boolean referencedIsCollection,
      ExpandItemImpl item,
      final boolean forRef, final boolean forCount) throws UriParserException, UriValidationException {
    if (tokenizer.next(TokenKind.OPEN)) {
      do {
        SystemQueryOption systemQueryOption;
        if (!forCount && tokenizer.next(TokenKind.COUNT)) {
          ParserHelper.requireNext(tokenizer, TokenKind.EQ);
          ParserHelper.requireNext(tokenizer, TokenKind.BooleanValue);
          CountOptionImpl countOption = new CountOptionImpl();
          countOption.setText(tokenizer.getText());
          countOption.setValue(Boolean.parseBoolean(tokenizer.getText()));
          systemQueryOption = countOption;

        } else if (!forRef && !forCount && tokenizer.next(TokenKind.EXPAND)) {
          ParserHelper.requireNext(tokenizer, TokenKind.EQ);
          systemQueryOption = new ExpandParser(edm, odata, aliases, null).parse(tokenizer, referencedType);

        } else if (tokenizer.next(TokenKind.FILTER)) {
          ParserHelper.requireNext(tokenizer, TokenKind.EQ);
          systemQueryOption = new FilterParser(edm, odata).parse(tokenizer, referencedType, null, aliases);

        } else if (!forRef && !forCount && tokenizer.next(TokenKind.LEVELS)) {
          ParserHelper.requireNext(tokenizer, TokenKind.EQ);
          systemQueryOption = (SystemQueryOption) parseLevels(tokenizer);

        } else if (!forCount && tokenizer.next(TokenKind.ORDERBY)) {
          ParserHelper.requireNext(tokenizer, TokenKind.EQ);
          systemQueryOption = new OrderByParser(edm, odata).parse(tokenizer, referencedType, null, aliases);

        } else if (tokenizer.next(TokenKind.SEARCH)) {
          ParserHelper.requireNext(tokenizer, TokenKind.EQ);
          systemQueryOption = new SearchParser().parse(tokenizer);

        } else if (!forRef && !forCount && tokenizer.next(TokenKind.SELECT)) {
          ParserHelper.requireNext(tokenizer, TokenKind.EQ);
          systemQueryOption = new SelectParser(edm).parse(tokenizer, referencedType, referencedIsCollection);

        } else if (!forCount && tokenizer.next(TokenKind.SKIP)) {
          ParserHelper.requireNext(tokenizer, TokenKind.EQ);
          ParserHelper.requireNext(tokenizer, TokenKind.IntegerValue);
          final int value = ParserHelper.parseNonNegativeInteger(SystemQueryOptionKind.SKIP.toString(),
              tokenizer.getText(), true);
          SkipOptionImpl skipOption = new SkipOptionImpl();
          skipOption.setText(tokenizer.getText());
          skipOption.setValue(value);
          systemQueryOption = skipOption;

        } else if (!forCount && tokenizer.next(TokenKind.TOP)) {
          ParserHelper.requireNext(tokenizer, TokenKind.EQ);
          ParserHelper.requireNext(tokenizer, TokenKind.IntegerValue);
          final int value = ParserHelper.parseNonNegativeInteger(SystemQueryOptionKind.TOP.toString(),
              tokenizer.getText(), true);
          TopOptionImpl topOption = new TopOptionImpl();
          topOption.setText(tokenizer.getText());
          topOption.setValue(value);
          systemQueryOption = topOption;

        } else {
          throw new UriParserSyntaxException("Allowed query option expected.",
              UriParserSyntaxException.MessageKeys.SYNTAX);
        }
        try {
          item.setSystemQueryOption(systemQueryOption);
        } catch (final ODataRuntimeException e) {
          throw new UriParserSyntaxException("Double system query option '" + systemQueryOption.getName() + "'.", e,
              UriParserSyntaxException.MessageKeys.DOUBLE_SYSTEM_QUERY_OPTION, systemQueryOption.getName());
        }
      } while (tokenizer.next(TokenKind.SEMI));
      ParserHelper.requireNext(tokenizer, TokenKind.CLOSE);
    }
  }

  private LevelsExpandOption parseLevels(UriTokenizer tokenizer) throws UriParserException {
    final LevelsOptionImpl option = new LevelsOptionImpl();
    if (tokenizer.next(TokenKind.MAX)) {
      option.setText(tokenizer.getText());
      option.setMax();
    } else {
      ParserHelper.requireNext(tokenizer, TokenKind.IntegerValue);
      option.setText(tokenizer.getText());
      option.setValue(
          ParserHelper.parseNonNegativeInteger(SystemQueryOptionKind.LEVELS.toString(), tokenizer.getText(), false));
    }
    return option;
  }
}