// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

part of 'constant_evaluator.dart';

abstract class _ListOrSetConstantBuilder<L extends Expression,
    C extends Constant> {
  final ConstantEvaluator evaluator;
  final Expression original;
  final DartType elementType;

  // Each element of [parts] is either a `List<Constant>` (containing fully
  // evaluated constants) or a `Constant` (potentially unevaluated).
  List<Object> parts = <Object>[<Constant>[]];

  _ListOrSetConstantBuilder(this.original, this.elementType, this.evaluator);

  L makeLiteral(List<Expression> elements);

  C makeConstant(List<Constant> elements);

  Message get messageForIteration;

  _ListOrSetConstantBuilder<L, C> newTempBuilder();

  /// Add an element (which is possibly a spread or an if element) to the
  /// constant list being built by this builder.
  void add(Expression element) {
    if (element is SpreadElement) {
      addSpread(element.expression, isNullAware: element.isNullAware);
    } else if (element is IfElement) {
      Constant condition = evaluator._evaluateSubexpression(element.condition);
      if (evaluator.shouldBeUnevaluated) {
        // Unevaluated if
        evaluator.enterLazy();
        Constant then = (newTempBuilder()..add(element.then)).build();
        Constant otherwise;
        if (element.otherwise != null) {
          otherwise = (newTempBuilder()..add(element.otherwise)).build();
        } else {
          otherwise = makeConstant([]);
        }
        evaluator.leaveLazy();
        parts.add(evaluator.unevaluated(
            element.condition,
            new ConditionalExpression(
                evaluator.extract(condition),
                evaluator.extract(then),
                evaluator.extract(otherwise),
                const DynamicType())));
      } else {
        // Fully evaluated if
        if (condition == evaluator.trueConstant) {
          add(element.then);
        } else if (condition == evaluator.falseConstant) {
          if (element.otherwise != null) {
            add(element.otherwise);
          }
        } else if (condition == evaluator.nullConstant) {
          evaluator.report(element.condition, messageConstEvalNullValue);
        } else {
          evaluator.report(
              element.condition,
              templateConstEvalInvalidType.withArguments(
                  condition,
                  evaluator.typeEnvironment.boolType,
                  condition.getType(evaluator.typeEnvironment)));
        }
      }
    } else if (element is ForElement || element is ForInElement) {
      // For or for-in
      evaluator.report(element, messageForIteration);
    } else {
      // Ordinary expression element
      Constant constant = evaluator._evaluateSubexpression(element);
      if (evaluator.shouldBeUnevaluated) {
        parts.add(evaluator.unevaluated(
            element, makeLiteral([evaluator.extract(constant)])));
      } else {
        addConstant(constant, element);
      }
    }
  }

  void addSpread(Expression spreadExpression, {bool isNullAware}) {
    Constant spread =
        evaluator.unlower(evaluator._evaluateSubexpression(spreadExpression));
    if (evaluator.shouldBeUnevaluated) {
      // Unevaluated spread
      if (isNullAware) {
        VariableDeclaration temp = new VariableDeclaration(null,
            initializer: evaluator.extract(spread));
        parts.add(evaluator.unevaluated(
            spreadExpression,
            new Let(
                temp,
                new ConditionalExpression(
                    new MethodInvocation(new VariableGet(temp), new Name('=='),
                        new Arguments([new NullLiteral()])),
                    new ListLiteral([], isConst: true),
                    new VariableGet(temp),
                    const DynamicType()))));
      } else {
        parts.add(spread);
      }
    } else if (spread == evaluator.nullConstant) {
      // Null spread
      if (!isNullAware) {
        evaluator.report(spreadExpression, messageConstEvalNullValue);
      }
    } else {
      // Fully evaluated spread
      List<Constant> entries;
      if (spread is ListConstant) {
        entries = spread.entries;
      } else if (spread is SetConstant) {
        entries = spread.entries;
      } else {
        // Not list or set in spread
        return evaluator.report(
            spreadExpression, messageConstEvalNotListOrSetInSpread);
      }
      for (Constant entry in entries) {
        addConstant(entry, spreadExpression);
      }
    }
  }

  void addConstant(Constant constant, TreeNode context);

  Constant build();
}

class ListConstantBuilder
    extends _ListOrSetConstantBuilder<ListLiteral, ListConstant> {
  ListConstantBuilder(
      Expression original, DartType elementType, ConstantEvaluator evaluator)
      : super(original, elementType, evaluator);

  @override
  ListLiteral makeLiteral(List<Expression> elements) =>
      new ListLiteral(elements, isConst: true);

  @override
  ListConstant makeConstant(List<Constant> elements) =>
      new ListConstant(const DynamicType(), elements);

  @override
  Message get messageForIteration => messageConstEvalIterationInConstList;

  @override
  ListConstantBuilder newTempBuilder() =>
      new ListConstantBuilder(original, const DynamicType(), evaluator);

  @override
  void addConstant(Constant constant, TreeNode context) {
    List<Constant> lastPart;
    if (parts.last is List<Constant>) {
      lastPart = parts.last;
    } else {
      parts.add(lastPart = <Constant>[]);
    }
    lastPart.add(evaluator.ensureIsSubtype(constant, elementType, context));
  }

  @override
  Constant build() {
    if (parts.length == 1) {
      // Fully evaluated
      return evaluator
          .lowerListConstant(new ListConstant(elementType, parts.single));
    }
    List<Expression> lists = <Expression>[];
    for (Object part in parts) {
      if (part is List<Constant>) {
        lists.add(new ConstantExpression(new ListConstant(elementType, part)));
      } else if (part is Constant) {
        lists.add(evaluator.extract(part));
      } else {
        throw 'Non-constant in constant list';
      }
    }
    return evaluator.unevaluated(
        original, new ListConcatenation(lists, typeArgument: elementType));
  }
}

class SetConstantBuilder
    extends _ListOrSetConstantBuilder<SetLiteral, SetConstant> {
  final Set<Constant> seen = new Set<Constant>.identity();

  SetConstantBuilder(
      Expression original, DartType elementType, ConstantEvaluator evaluator)
      : super(original, elementType, evaluator);

  @override
  SetLiteral makeLiteral(List<Expression> elements) =>
      new SetLiteral(elements, isConst: true);

  @override
  SetConstant makeConstant(List<Constant> elements) =>
      new SetConstant(const DynamicType(), elements);

  @override
  Message get messageForIteration => messageConstEvalIterationInConstSet;

  @override
  SetConstantBuilder newTempBuilder() =>
      new SetConstantBuilder(original, const DynamicType(), evaluator);

  @override
  void addConstant(Constant constant, TreeNode context) {
    if (!evaluator.hasPrimitiveEqual(constant)) {
      evaluator.report(context,
          templateConstEvalElementImplementsEqual.withArguments(constant));
    }
    if (!seen.add(constant)) {
      evaluator.report(
          context, templateConstEvalDuplicateElement.withArguments(constant));
    }

    List<Constant> lastPart;
    if (parts.last is List<Constant>) {
      lastPart = parts.last;
    } else {
      parts.add(lastPart = <Constant>[]);
    }
    lastPart.add(evaluator.ensureIsSubtype(constant, elementType, context));
  }

  @override
  Constant build() {
    if (parts.length == 1) {
      // Fully evaluated
      List<Constant> entries = parts.single;
      SetConstant result = new SetConstant(elementType, entries);
      if (evaluator.desugarSets) {
        final List<ConstantMapEntry> mapEntries =
            new List<ConstantMapEntry>(entries.length);
        for (int i = 0; i < entries.length; ++i) {
          mapEntries[i] =
              new ConstantMapEntry(entries[i], evaluator.nullConstant);
        }
        Constant map = evaluator.lowerMapConstant(new MapConstant(
            elementType, evaluator.typeEnvironment.nullType, mapEntries));
        return evaluator.lower(
            result,
            new InstanceConstant(
                evaluator.unmodifiableSetMap.enclosingClass.reference, [
              elementType
            ], <Reference, Constant>{
              evaluator.unmodifiableSetMap.reference: map
            }));
      } else {
        return evaluator.lowerSetConstant(result);
      }
    }
    List<Expression> sets = <Expression>[];
    for (Object part in parts) {
      if (part is List<Constant>) {
        sets.add(new ConstantExpression(new SetConstant(elementType, part)));
      } else if (part is Constant) {
        sets.add(evaluator.extract(part));
      } else {
        throw 'Non-constant in constant set';
      }
    }
    return evaluator.unevaluated(
        original, new SetConcatenation(sets, typeArgument: elementType));
  }
}

class MapConstantBuilder {
  final ConstantEvaluator evaluator;
  final Expression original;
  final DartType keyType;
  final DartType valueType;

  /// Each element of [parts] is either a `List<ConstantMapEntry>` (containing
  /// fully evaluated map entries) or a `Constant` (potentially unevaluated).
  List<Object> parts = <Object>[<ConstantMapEntry>[]];

  final Set<Constant> seenKeys = new Set<Constant>.identity();

  MapConstantBuilder(
      this.original, this.keyType, this.valueType, this.evaluator);

  MapConstantBuilder newTempBuilder() => new MapConstantBuilder(
      original, const DynamicType(), const DynamicType(), evaluator);

  /// Add a map entry (which is possibly a spread or an if map entry) to the
  /// constant map being built by this builder
  void add(MapEntry element) {
    if (element is SpreadMapEntry) {
      addSpread(element.expression, isNullAware: element.isNullAware);
    } else if (element is IfMapEntry) {
      Constant condition = evaluator._evaluateSubexpression(element.condition);
      if (evaluator.shouldBeUnevaluated) {
        // Unevaluated if
        evaluator.enterLazy();
        Constant then = (newTempBuilder()..add(element.then)).build();
        Constant otherwise;
        if (element.otherwise != null) {
          otherwise = (newTempBuilder()..add(element.otherwise)).build();
        } else {
          otherwise =
              new MapConstant(const DynamicType(), const DynamicType(), []);
        }
        evaluator.leaveLazy();
        parts.add(evaluator.unevaluated(
            element.condition,
            new ConditionalExpression(
                evaluator.extract(condition),
                evaluator.extract(then),
                evaluator.extract(otherwise),
                const DynamicType())));
      } else {
        // Fully evaluated if
        if (condition == evaluator.trueConstant) {
          add(element.then);
        } else if (condition == evaluator.falseConstant) {
          if (element.otherwise != null) {
            add(element.otherwise);
          }
        } else if (condition == evaluator.nullConstant) {
          evaluator.report(element.condition, messageConstEvalNullValue);
        } else {
          evaluator.report(
              element.condition,
              templateConstEvalInvalidType.withArguments(
                  condition,
                  evaluator.typeEnvironment.boolType,
                  condition.getType(evaluator.typeEnvironment)));
        }
      }
    } else if (element is ForMapEntry || element is ForInMapEntry) {
      // For or for-in
      evaluator.report(element, messageConstEvalIterationInConstMap);
    } else {
      // Ordinary map entry
      Constant key = evaluator._evaluateSubexpression(element.key);
      Constant value = evaluator._evaluateSubexpression(element.value);
      if (evaluator.shouldBeUnevaluated) {
        parts.add(evaluator.unevaluated(
            element.key,
            new MapLiteral([
              new MapEntry(evaluator.extract(key), evaluator.extract(value))
            ], isConst: true)));
      } else {
        addConstant(key, value, element.key, element.value);
      }
    }
  }

  void addSpread(Expression spreadExpression, {bool isNullAware}) {
    Constant spread =
        evaluator.unlower(evaluator._evaluateSubexpression(spreadExpression));
    if (evaluator.shouldBeUnevaluated) {
      // Unevaluated spread
      if (isNullAware) {
        VariableDeclaration temp = new VariableDeclaration(null,
            initializer: evaluator.extract(spread));
        parts.add(evaluator.unevaluated(
            spreadExpression,
            new Let(
                temp,
                new ConditionalExpression(
                    new MethodInvocation(new VariableGet(temp), new Name('=='),
                        new Arguments([new NullLiteral()])),
                    new MapLiteral([], isConst: true),
                    new VariableGet(temp),
                    const DynamicType()))));
      } else {
        parts.add(spread);
      }
    } else if (spread == evaluator.nullConstant) {
      // Null spread
      if (!isNullAware) {
        evaluator.report(spreadExpression, messageConstEvalNullValue);
      }
    } else {
      // Fully evaluated spread
      if (spread is MapConstant) {
        for (ConstantMapEntry entry in spread.entries) {
          addConstant(
              entry.key, entry.value, spreadExpression, spreadExpression);
        }
      } else {
        // Not map in spread
        return evaluator.report(
            spreadExpression, messageConstEvalNotMapInSpread);
      }
    }
  }

  void addConstant(Constant key, Constant value, TreeNode keyContext,
      TreeNode valueContext) {
    List<ConstantMapEntry> lastPart;
    if (parts.last is List<ConstantMapEntry>) {
      lastPart = parts.last;
    } else {
      parts.add(lastPart = <ConstantMapEntry>[]);
    }
    if (!evaluator.hasPrimitiveEqual(key)) {
      evaluator.report(
          keyContext, templateConstEvalKeyImplementsEqual.withArguments(key));
    }
    if (!seenKeys.add(key)) {
      evaluator.report(
          keyContext, templateConstEvalDuplicateKey.withArguments(key));
    }
    lastPart.add(new ConstantMapEntry(
        evaluator.ensureIsSubtype(key, keyType, keyContext),
        evaluator.ensureIsSubtype(value, valueType, valueContext)));
  }

  Constant build() {
    if (parts.length == 1) {
      // Fully evaluated
      return evaluator
          .lowerMapConstant(new MapConstant(keyType, valueType, parts.single));
    }
    List<Expression> maps = <Expression>[];
    for (Object part in parts) {
      if (part is List<ConstantMapEntry>) {
        maps.add(
            new ConstantExpression(new MapConstant(keyType, valueType, part)));
      } else if (part is Constant) {
        maps.add(evaluator.extract(part));
      } else {
        throw 'Non-constant in constant map';
      }
    }
    return evaluator.unevaluated(original,
        new MapConcatenation(maps, keyType: keyType, valueType: valueType));
  }
}