// Copyright (c) 2017, the R8 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.
package com.android.tools.r8.graph;

import static com.android.tools.r8.utils.StringUtils.LINE_SEPARATOR;

import com.android.tools.r8.ClassFileConsumer;
import com.android.tools.r8.contexts.CompilationContext;
import com.android.tools.r8.graph.GenericSignature.ClassSignature;
import com.android.tools.r8.ir.conversion.IRConverter;
import com.android.tools.r8.ir.conversion.MethodConversionOptions;
import com.android.tools.r8.ir.conversion.MethodProcessorEventConsumer;
import com.android.tools.r8.ir.conversion.OneTimeMethodProcessor;
import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackIgnore;
import com.android.tools.r8.kotlin.Kotlin;
import com.android.tools.r8.kotlin.KotlinMetadataWriter;
import com.android.tools.r8.synthesis.SyntheticItems.GlobalSyntheticsStrategy;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.RetracerForCodePrinting;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.StringUtils.BraceType;
import java.io.BufferedReader;
import java.io.PrintStream;
import java.io.StringReader;
import java.util.stream.Collectors;

public class AssemblyWriter extends DexByteCodeWriter {

  private final boolean writeAllClassInfo;
  private final boolean writeFields;
  private final boolean writeAnnotations;
  private final boolean writeIR;
  private final boolean writeCode;
  private final AppInfo appInfo;
  private final Kotlin kotlin;
  private final CompilationContext compilationContext;
  private final RetracerForCodePrinting retracer;

  public AssemblyWriter(
      DexApplication application,
      InternalOptions options,
      boolean allInfo,
      boolean writeIR,
      boolean writeCode) {
    super(application, options);
    this.compilationContext = CompilationContext.createInitialContext(options);
    this.writeAllClassInfo = allInfo;
    this.writeFields = allInfo;
    this.writeAnnotations = allInfo;
    this.writeIR = writeIR;
    this.writeCode = writeCode;
    if (writeIR) {
      this.appInfo =
          AppInfo.createInitialAppInfo(
              application.toDirect(), GlobalSyntheticsStrategy.forNonSynthesizing());
      if (options.programConsumer == null) {
        // Use class-file backend, since the CF frontend for testing does not support desugaring of
        // synchronized methods for the DEX backend (b/109789541).
        options.programConsumer = ClassFileConsumer.emptyConsumer();
      }
      options.outline.enabled = false;
    } else {
      this.appInfo = null;
    }
    kotlin = new Kotlin(application.dexItemFactory);
    retracer =
        RetracerForCodePrinting.create(application.getProguardMap(), application.options.reporter);
  }

  public static String getFileEnding() {
    return ".dump";
  }

  @Override
  @SuppressWarnings("ReferenceEquality")
  void writeClassHeader(DexProgramClass clazz, PrintStream ps) {
    String clazzName = retracer.toSourceString(clazz.getType());
    ps.println("# Bytecode for");
    ps.println("# Class: '" + clazzName + "'");
    if (writeAllClassInfo) {
      ClassSignature signature = clazz.getClassSignature();
      if (signature != null && signature.hasSignature()) {
        ps.println("# Signature: " + signature);
      }
      writeAnnotations(clazz, clazz.annotations(), ps);
      ps.println("# Flags: '" + clazz.accessFlags + "'");
      if (clazz.superType != application.dexItemFactory.objectType) {
        ps.println("# Extends: '" + retracer.toSourceString(clazz.superType) + "'");
      }
      for (DexType value : clazz.interfaces.values) {
        ps.println("# Implements: '" + retracer.toSourceString(value) + "'");
      }
      if (!clazz.getInnerClasses().isEmpty()) {
        ps.println("# InnerClasses:");
        for (InnerClassAttribute innerClassAttribute : clazz.getInnerClasses()) {
          ps.println(
              "#  Outer: "
                  + (innerClassAttribute.getOuter() != null
                      ? retracer.toSourceString(innerClassAttribute.getOuter())
                      : "-")
                  + ", inner: "
                  + retracer.toSourceString(innerClassAttribute.getInner())
                  + ", inner name: "
                  + innerClassAttribute.getInnerName()
                  + ", access: "
                  + Integer.toHexString(innerClassAttribute.getAccess()));
        }
      }
      EnclosingMethodAttribute enclosingMethodAttribute = clazz.getEnclosingMethodAttribute();
      if (enclosingMethodAttribute != null) {
        ps.println("# EnclosingMethod:");
        if (enclosingMethodAttribute.getEnclosingClass() != null) {
          ps.println(
              "#  Class: " + retracer.toSourceString(enclosingMethodAttribute.getEnclosingClass()));
        } else {
          ps.println(
              "#  Method: "
                  + retracer.toSourceString(enclosingMethodAttribute.getEnclosingMethod()));
        }
      }
    }
    ps.println();
  }

  @Override
  void writeFieldsHeader(DexProgramClass clazz, PrintStream ps) {
    if (writeFields) {
      ps.println("#");
      ps.println("# Fields:");
      ps.println("#");
    }
  }

  @Override
  void writeField(DexEncodedField field, PrintStream ps) {
    if (writeFields) {
      writeAnnotations(null, field.annotations(), ps);
      ps.print(field.accessFlags + " ");
      ps.print(retracer.toSourceString(field.getReference()));
      if (field.isStatic() && field.hasExplicitStaticValue()) {
        ps.print(" = " + field.getStaticValue());
      }
      ps.println();
      if (!retracer.isEmpty()) {
        ps.println("# Residual: '" + field.getReference().toSourceString() + "'");
      }
      if (field.hasNonIdentityOriginalFieldWitness()) {
        ps.println("# Original: '" + field.getOriginalFieldWitness() + "'");
      }
    }
  }

  @Override
  void writeFieldsFooter(DexProgramClass clazz, PrintStream ps) {
    ps.println();
  }

  @Override
  void writeMethod(ProgramMethod method, PrintStream ps) {
    DexEncodedMethod definition = method.getDefinition();
    ps.println("#");
    ps.println("# Method: '" + retracer.toSourceString(definition.getReference()) + "':");
    writeAnnotations(null, definition.annotations(), ps);
    ps.println("# " + definition.accessFlags);
    if (!retracer.isEmpty()) {
      ps.println("# Residual: '" + definition.getReference().toSourceString() + "'");
    }
    ps.println("#");
    ps.println();
    if (!writeCode) {
      return;
    }
    Code code = definition.getCode();
    if (code != null) {
      if (writeIR) {
        writeIR(method);
      } else {
        ps.println(code.toString(definition, retracer));
      }
    }
  }

  private void writeIR(ProgramMethod method) {
    IRConverter converter = new IRConverter(appInfo);
    MethodProcessorEventConsumer eventConsumer = MethodProcessorEventConsumer.empty();
    OneTimeMethodProcessor methodProcessor =
        OneTimeMethodProcessor.create(
            method, eventConsumer, compilationContext.createProcessorContext());
    methodProcessor.forEachWaveWithExtension(
        (ignore, methodProcessingContext) ->
            converter.processDesugaredMethod(
                method,
                OptimizationFeedbackIgnore.getInstance(),
                methodProcessor,
                methodProcessingContext,
                MethodConversionOptions.forD8(converter.appView)));
  }

  @SuppressWarnings("ReferenceEquality")
  private void writeAnnotations(
      DexProgramClass clazz, DexAnnotationSet annotations, PrintStream ps) {
    if (writeAnnotations) {
      if (!annotations.isEmpty()) {
        ps.println("# Annotations:");
        String prefix = "#  ";
        for (DexAnnotation annotation : annotations.annotations) {
          if (annotation.annotation.type == kotlin.factory.kotlinMetadataType) {
            assert clazz != null : "Kotlin metadata is a class annotation";
            KotlinMetadataWriter.writeKotlinMetadataAnnotation(prefix, annotation, ps, kotlin);
          } else {
            StringBuilder sb = new StringBuilder();
            sb.append(annotation.getVisibility());
            sb.append(" ");
            sb.append(retracer.toSourceString(annotation.getAnnotationType()));
            sb.append(
                StringUtils.join(
                    ",",
                    annotation.annotation.elements,
                    element ->
                        element.getName().toString() + " = " + getStringValue(element.getValue()),
                    BraceType.SQUARE));
            ps.print(
                new BufferedReader(new StringReader(sb.toString()))
                    .lines()
                    .collect(
                        Collectors.joining(
                            LINE_SEPARATOR + prefix + "  ", prefix, LINE_SEPARATOR)));
          }
        }
      }
    }
  }

  private String getStringValue(DexValue value) {
    if (value.isDexValueType()) {
      return retracer.toSourceString(value.asDexValueType().getValue());
    } else if (value.isDexValueMethodHandle()) {
      return retracer.toSourceString(value.asDexValueMethodHandle().value.asMethod());
    } else if (value.isDexValueMethod()) {
      return retracer.toSourceString(value.asDexValueMethod().value);
    } else if (value.isDexItemBasedValueString()) {
      return retracer.toSourceString(value.asDexItemBasedValueString().value);
    } else if (value.isDexValueEnum()) {
      return retracer.toSourceString(value.asDexValueEnum().value);
    } else if (value.isDexValueField()) {
      return retracer.toSourceString(value.asDexValueField().value);
    } else if (value.isDexValueArray()) {
      return "[" + value.asDexValueArray() + "]";
    } else {
      return value.toString();
    }
  }

  @Override
  void writeClassFooter(DexProgramClass clazz, PrintStream ps) {

  }
}