/*
 * Copyright 2016-present Facebook, Inc.
 *
 * Licensed 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 com.facebook.buck.jvm.java;

import com.google.common.base.Function;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import javax.annotation.Nullable;
import javax.lang.model.element.Modifier;
import javax.lang.model.element.NestingKind;
import javax.tools.FileObject;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;

class FakeStandardJavaFileManager implements StandardJavaFileManager {

  private static final Function<File, JavaFileObject> fileToJavaFileObject =
      new Function<File, JavaFileObject>() {
        @Nullable
        @Override
        public JavaFileObject apply(@Nullable File input) {
          return new FakeJavaFileObject(null, input.getName(), JavaFileObject.Kind.CLASS);
        }
      };

  private static final Function<String, JavaFileObject> stringToJavaFileObject =
      new Function<String, JavaFileObject>() {
        @Nullable
        @Override
        public JavaFileObject apply(@Nullable String input) {
          return new FakeJavaFileObject(null, input, JavaFileObject.Kind.CLASS);
        }
      };

  private List<JavaFileObject> files = new ArrayList<>();

  public void addFile(Path jarPath, String fileName, JavaFileObject.Kind kind) {
    files.add(new FakeJavaFileObject(jarPath, fileName, kind));
  }

  private JavaFileObject getFile(String fileName) {
    for (JavaFileObject file : files) {
      if (file.getName().equals(fileName)) {
        return file;
      }
    }

    return null;
  }

  @Override
  public Iterable<JavaFileObject> list(
      Location location, String packageName, Set<JavaFileObject.Kind> kinds, boolean recurse)
      throws IOException {
    return files;
  }

  @Override
  public JavaFileObject getJavaFileForInput(
      Location location, String className, JavaFileObject.Kind kind) throws IOException {
    return getFile(className);
  }

  @Override
  public JavaFileObject getJavaFileForOutput(
      Location location, String className, JavaFileObject.Kind kind, FileObject sibling)
      throws IOException {
    return getFile(className);
  }

  @Override
  public FileObject getFileForInput(Location location, String packageName, String relativeName)
      throws IOException {
    return getFile(relativeName);
  }

  @Override
  public FileObject getFileForOutput(
      Location location, String packageName, String relativeName, FileObject sibling)
      throws IOException {
    return getFile(relativeName);
  }

  @Override
  public Iterable<? extends JavaFileObject> getJavaFileObjectsFromFiles(
      Iterable<? extends File> files) {
    return Iterables.transform(files, fileToJavaFileObject);
  }

  @Override
  public Iterable<? extends JavaFileObject> getJavaFileObjects(File... files) {
    return Iterables.transform(Lists.newArrayList(files), fileToJavaFileObject);
  }

  @Override
  public Iterable<? extends JavaFileObject> getJavaFileObjectsFromStrings(Iterable<String> names) {
    return Iterables.transform(names, stringToJavaFileObject);
  }

  @Override
  public Iterable<? extends JavaFileObject> getJavaFileObjects(String... names) {
    return Iterables.transform(Lists.newArrayList(names), stringToJavaFileObject);
  }

  @Override
  public ClassLoader getClassLoader(Location location) {
    throw new UnsupportedOperationException();
  }

  @Override
  public String inferBinaryName(Location location, JavaFileObject file) {
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean isSameFile(FileObject a, FileObject b) {
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean handleOption(String current, Iterator<String> remaining) {
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean hasLocation(Location location) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void flush() throws IOException {
    throw new UnsupportedOperationException();
  }

  @Override
  public void close() throws IOException {
    throw new UnsupportedOperationException();
  }

  @Override
  public void setLocation(Location location, Iterable<? extends File> path) throws IOException {
    throw new UnsupportedOperationException();
  }

  @Override
  public Iterable<? extends File> getLocation(Location location) {
    throw new UnsupportedOperationException();
  }

  @Override
  public int isSupportedOption(String option) {
    throw new UnsupportedOperationException();
  }

  public static class FakeJavaFileObject extends FakeFileObject implements JavaFileObject {

    private final Kind kind;

    private FakeJavaFileObject(@Nullable Path jarPath, String name, Kind kind) {
      super(jarPath, name);
      this.kind = kind;
    }

    @Override
    public Kind getKind() {
      return kind;
    }

    @Override
    public boolean isNameCompatible(String simpleName, Kind kind) {
      throw new UnsupportedOperationException();
    }

    @Override
    public NestingKind getNestingKind() {
      throw new UnsupportedOperationException();
    }

    @Override
    public Modifier getAccessLevel() {
      throw new UnsupportedOperationException();
    }
  }

  private static class FakeFileObject implements FileObject {

    @Nullable protected final Path jarPath;
    protected final String name;

    private FakeFileObject(@Nullable Path jarPath, String name) {
      this.jarPath = jarPath;
      this.name = name;
    }

    @Override
    public String getName() {
      return name;
    }

    private static String getJarPath(Path jarPath, String filePath) {
      return String.format("jar:%s!/%s", jarPath.toUri().toString(), filePath);
    }

    @Override
    public URI toUri() {
      try {
        if (jarPath == null) {
          return Paths.get(name).toUri();
        } else {
          return new URI(getJarPath(jarPath, name));
        }
      } catch (URISyntaxException e) {
        throw new AssertionError(e);
      }
    }

    @Override
    public InputStream openInputStream() throws IOException {
      return null;
    }

    @Override
    public Reader openReader(boolean ignoreEncodingErrors) throws IOException {
      return null;
    }

    @Override
    public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
      return null;
    }

    @Override
    public OutputStream openOutputStream() throws IOException {
      throw new UnsupportedOperationException();
    }

    @Override
    public Writer openWriter() throws IOException {
      throw new UnsupportedOperationException();
    }

    @Override
    public long getLastModified() {
      throw new UnsupportedOperationException();
    }

    @Override
    public boolean delete() {
      throw new UnsupportedOperationException();
    }
  }
}