/*
    * 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.maven.cling.invoker.mvn;
  
  import java.nio.file.Path;
  import java.nio.file.Paths;
  import java.time.Instant;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Objects;
  import java.util.Optional;
  import java.util.concurrent.ConcurrentHashMap;
  
  import org.apache.maven.api.Artifact;
  import org.apache.maven.api.Lifecycle;
  import org.apache.maven.api.Packaging;
  import org.apache.maven.api.ProducedArtifact;
  import org.apache.maven.api.Project;
  import org.apache.maven.api.RemoteRepository;
  import org.apache.maven.api.Session;
  import org.apache.maven.api.Type;
  import org.apache.maven.api.Version;
  import org.apache.maven.api.di.Provides;
  import org.apache.maven.api.di.SessionScoped;
  import org.apache.maven.api.model.PluginContainer;
  import org.apache.maven.api.model.Profile;
  import org.apache.maven.api.services.ArtifactManager;
  import org.apache.maven.api.services.LifecycleRegistry;
  import org.apache.maven.api.services.Lookup;
  import org.apache.maven.api.services.MavenException;
  import org.apache.maven.api.services.PackagingRegistry;
  import org.apache.maven.api.services.RepositoryFactory;
  import org.apache.maven.api.services.SettingsBuilder;
  import org.apache.maven.api.services.TypeRegistry;
  import org.apache.maven.api.settings.Settings;
  import org.apache.maven.api.spi.TypeProvider;
  import org.apache.maven.di.Injector;
  import org.apache.maven.di.Key;
  import org.apache.maven.di.impl.DIException;
  import org.apache.maven.internal.impl.AbstractSession;
  import org.apache.maven.internal.impl.InternalSession;
  import org.apache.maven.internal.impl.di.SessionScope;
  import org.eclipse.aether.DefaultRepositorySystemSession;
  import org.eclipse.aether.RepositorySystem;
  import org.eclipse.aether.RepositorySystemSession;
  import org.eclipse.aether.impl.RemoteRepositoryManager;
  import org.eclipse.aether.repository.LocalRepository;
  import org.eclipse.aether.repository.LocalRepositoryManager;
  
  public class ProtoSession extends AbstractSession {
  
      private final Map<String, String> userProperties;
      private final Map<String, String> systemProperties;
      private final Instant startTime = Instant.now();
  
      ProtoSession(RepositorySystemSession session, RepositorySystem repositorySystem, Lookup lookup) {
          this(session, repositorySystem, Collections.emptyList(), null, lookup, new Context(Map.of(), Map.of()));
      }
  
      protected ProtoSession(
              RepositorySystemSession session,
              RepositorySystem repositorySystem,
              List<RemoteRepository> repositories,
              List<org.eclipse.aether.repository.RemoteRepository> resolverRepositories,
              Lookup lookup,
              Context context) {
          super(session, repositorySystem, repositories, resolverRepositories, lookup);
          userProperties = context.userProperties;
          systemProperties = context.systemProperties;
      }
  
      /**
       *
       */
      public static Session create() {
          Map<String, String> properties = new HashMap<>();
          // Env variables prefixed with "env."
          System.getenv().forEach((k, v) -> properties.put("env." + k, v));
          // Java System properties
          System.getProperties().forEach((k, v) -> properties.put(k.toString(), v.toString()));
         // create session
         return create(Map.of(), properties);
     }
 
     /**
      * Create a new session.
      */
     public static Session create(Map<String, String> userProperties, Map<String, String> systemProperties) {
         Injector injector = Injector.create();
         injector.bindInstance(Injector.class, injector);
         injector.bindInstance(Context.class, new Context(userProperties, systemProperties));
         injector.bindImplicit(Providers.class);
         injector.discover(ProtoSession.class.getClassLoader());
         Session session = injector.getInstance(Session.class);
         SessionScope scope = new SessionScope();
         scope.enter();
         scope.seed(Session.class, session);
         injector.bindScope(SessionScoped.class, scope);
         return session;
     }
 
     record Context(Map<String, String> userProperties, Map<String, String> systemProperties) {}
 
     @Override
     protected Session newSession(RepositorySystemSession session, List<RemoteRepository> repositories) {
         return new ProtoSession(
                 session, repositorySystem, repositories, null, lookup, new Context(userProperties, systemProperties));
     }
 
     @Override
     public Settings getSettings() {
         return Settings.newInstance();
     }
 
     @Override
     public Map<String, String> getUserProperties() {
         return Map.of();
     }
 
     @Override
     public Map<String, String> getSystemProperties() {
         return systemProperties;
     }
 
     @Override
     public Map<String, String> getEffectiveProperties(Project project) {
         HashMap<String, String> result = new HashMap<>(getSystemProperties());
         if (project != null) {
             result.putAll(project.getModel().getProperties());
         }
         result.putAll(getUserProperties());
         return result;
     }
 
     @Override
     public Version getMavenVersion() {
         return null;
     }
 
     @Override
     public int getDegreeOfConcurrency() {
         return 0;
     }
 
     @Override
     public Instant getStartTime() {
         return startTime;
     }
 
     @Override
     public Path getTopDirectory() {
         return null;
     }
 
     @Override
     public Path getRootDirectory() {
         throw new IllegalStateException();
     }
 
     @Override
     public List<Project> getProjects() {
         return List.of();
     }
 
     @Override
     public Map<String, Object> getPluginContext(Project project) {
         throw new UnsupportedInStandaloneModeException();
     }
 
     static class Providers {
 
         @Provides
         @SuppressWarnings("unused")
         static Lookup newLookup(Injector injector) {
             return new Lookup() {
                 @Override
                 public <T> T lookup(Class<T> type) {
                     try {
                         return injector.getInstance(type);
                     } catch (DIException e) {
                         throw new MavenException("Unable to locate instance of type " + type, e);
                     }
                 }
 
                 @Override
                 public <T> T lookup(Class<T> type, String name) {
                     try {
                         return injector.getInstance(Key.of(type, name));
                     } catch (DIException e) {
                         throw new MavenException("Unable to locate instance of type " + type, e);
                     }
                 }
 
                 @Override
                 public <T> Optional<T> lookupOptional(Class<T> type) {
                     try {
                         return Optional.of(injector.getInstance(type));
                     } catch (DIException e) {
                         return Optional.empty();
                     }
                 }
 
                 @Override
                 public <T> Optional<T> lookupOptional(Class<T> type, String name) {
                     try {
                         return Optional.of(injector.getInstance(Key.of(type, name)));
                     } catch (DIException e) {
                         return Optional.empty();
                     }
                 }
 
                 @Override
                 public <T> List<T> lookupList(Class<T> type) {
                     return injector.getInstance(new Key<List<T>>() {});
                 }
 
                 @Override
                 public <T> Map<String, T> lookupMap(Class<T> type) {
                     return injector.getInstance(new Key<Map<String, T>>() {});
                 }
             };
         }
 
         @Provides
         @SuppressWarnings("unused")
         static ArtifactManager newArtifactManager() {
             return new ArtifactManager() {
                 private final Map<Artifact, Path> paths = new ConcurrentHashMap<>();
 
                 @Override
                 public Optional<Path> getPath(Artifact artifact) {
                     return Optional.ofNullable(paths.get(artifact));
                 }
 
                 @Override
                 public void setPath(ProducedArtifact artifact, Path path) {
                     paths.put(artifact, path);
                 }
             };
         }
 
         @Provides
         @SuppressWarnings("unused")
         static PackagingRegistry newPackagingRegistry(TypeRegistry typeRegistry) {
             return id -> Optional.of(new DumbPackaging(id, typeRegistry.require(id), Map.of()));
         }
 
         @Provides
         @SuppressWarnings("unused")
         static TypeRegistry newTypeRegistry(List<TypeProvider> providers) {
             return new TypeRegistry() {
                 @Override
                 public Optional<Type> lookup(String id) {
                     return providers.stream()
                             .flatMap(p -> p.provides().stream())
                             .filter(t -> Objects.equals(id, t.id()))
                             .findAny();
                 }
             };
         }
 
         @Provides
         @SuppressWarnings("unused")
         static LifecycleRegistry newLifecycleRegistry() {
             return new LifecycleRegistry() {
 
                 @Override
                 public Iterator<Lifecycle> iterator() {
                     return Collections.emptyIterator();
                 }
 
                 @Override
                 public Optional<Lifecycle> lookup(String id) {
                     return Optional.empty();
                 }
 
                 @Override
                 public List<String> computePhases(Lifecycle lifecycle) {
                     return List.of();
                 }
             };
         }
 
         @Provides
         @SuppressWarnings("unused")
         static RepositorySystemSupplier newRepositorySystemSupplier() {
             return new RepositorySystemSupplier();
         }
 
         @Provides
         @SuppressWarnings("unused")
         static RepositorySystem newRepositorySystem(RepositorySystemSupplier repositorySystemSupplier) {
             return repositorySystemSupplier.getRepositorySystem();
         }
 
         @Provides
         @SuppressWarnings("unused")
         static RemoteRepositoryManager newRemoteRepositoryManager(RepositorySystemSupplier repositorySystemSupplier) {
             return repositorySystemSupplier.getRemoteRepositoryManager();
         }
 
         @Provides
         @SuppressWarnings("unused")
         static Session newSession(RepositorySystem system, Lookup lookup, Context context) {
 
             // SettingsDecrypter settingsDecrypter =
             // (SettingsDecrypter)Objects.requireNonNull(this.createSettingsDecrypter(preBoot));
             //        new DefaultProfileSelector(List.of(
             //                new JdkVersionProfileActivator(),
             //                new PropertyProfileActivator(),
             //                new OperatingSystemProfileActivator(),
             //                new FileProfileActivator(new ProfileActivationFilePathInterpolator(
             //                        new DefaultPathTranslator(), new DefaultRootLocator()))));
             Map<String, String> properties = context.systemProperties;
 
             Path userHome = Paths.get(properties.get("user.home"));
             Path mavenUserHome = userHome.resolve(".m2");
             Path mavenSystemHome = properties.containsKey("maven.home")
                     ? Paths.get(properties.get("maven.home"))
                     : properties.containsKey("env.MAVEN_HOME") ? Paths.get(properties.get("env.MAVEN_HOME")) : null;
 
             DefaultRepositorySystemSession rsession = new DefaultRepositorySystemSession(h -> false);
             rsession.setSystemProperties(properties);
             rsession.setConfigProperties(properties);
 
             ProtoSession session = new ProtoSession(
                     rsession,
                     system,
                     List.of(lookup.lookup(RepositoryFactory.class)
                             .createRemote("central", "https://repo.maven.apache.org/maven2")),
                     null,
                     lookup,
                     context);
 
             Settings settings = session.getService(SettingsBuilder.class)
                     .build(
                             session,
                             mavenSystemHome != null ? mavenSystemHome.resolve("settings.xml") : null,
                             mavenUserHome.resolve("settings.xml"))
                     .getEffectiveSettings();
 
             settings.getProfiles();
 
             // local repository
             String localRepository = settings.getLocalRepository() != null
                     ? settings.getLocalRepository()
                     : mavenUserHome.resolve("repository").toString();
             LocalRepositoryManager llm =
                     system.newLocalRepositoryManager(rsession, new LocalRepository(localRepository));
             rsession.setLocalRepositoryManager(llm);
             // active proxies
             // TODO
             // active profiles
 
             //        DefaultSession defaultSession = new DefaultSession(
             //                rsession,
             //                system,
             //                List.of(lookup.lookup(RepositoryFactory.class)
             //                        .createRemote("central", "https://repo.maven.apache.org/maven2")),
             //                null,
             //                lookup);
 
             Profile profile = session.getService(SettingsBuilder.class)
                     .convert(org.apache.maven.api.settings.Profile.newBuilder()
                             .repositories(settings.getRepositories())
                             .pluginRepositories(settings.getPluginRepositories())
                             .build());
             RepositoryFactory repositoryFactory = session.getService(RepositoryFactory.class);
             List<RemoteRepository> repositories = profile.getRepositories().stream()
                     .map(repositoryFactory::createRemote)
                     .toList();
             InternalSession s = (InternalSession) session.withRemoteRepositories(repositories);
             InternalSession.associate(rsession, s);
             return s;
 
             // List<RemoteRepository> repositories = repositoryFactory.createRemote();
 
             //        session.getService(SettingsBuilder.class).convert()
 
             //        settings.getDelegate().getRepositories().stream()
             //                        .map(r -> SettingsUtilsV4.)
             //        defaultSession.getService(RepositoryFactory.class).createRemote()
             //        return defaultSession;
         }
     }
 
     static class UnsupportedInStandaloneModeException extends MavenException {}
 
     record DumbPackaging(String id, Type type, Map<String, PluginContainer> plugins) implements Packaging {}
 }