/*
 * 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
<<<<<<< Updated upstream
 *
 *     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
=======
 * 
 *     https://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 
>>>>>>> Stashed changes
 * limitations under the License.
 */

package javax.jdo.stub;

import java.util.Collection;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import javax.jdo.Constants;
import javax.jdo.FetchGroup;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;
import javax.jdo.datastore.DataStoreCache;
import javax.jdo.listener.InstanceLifecycleListener;
import javax.jdo.metadata.JDOMetadata;
import javax.jdo.metadata.TypeMetadata;

public class StubPMF implements PersistenceManagerFactory, Constants {

  private static final long serialVersionUID = 488698916248368422L;

  public static PersistenceManagerFactory getPersistenceManagerFactory(Map<?, ?> props) {

    StubPMF pmf = new StubPMF();

    pmf.setProperties(props);

    for (Object key : props.keySet()) {
      if (!(key instanceof String)) {
        continue;
      }
      String prop = (String) key;
      if (!prop.startsWith("javax.jdo.")) {
        continue;
      }
      pmf.setProperty(prop, props.get(prop));
    }

    return pmf;
  }

  public static PersistenceManagerFactory getPersistenceManagerFactory(
      Map<?, ?> overrides, Map<?, ?> props) {

    StubPMF pmf = new StubPMF();

    pmf.setProperties(props);
    pmf.setProperties(overrides);

    return pmf;
  }

  String name;
  String persistenceManagerFactoryClassName;
  String spiResourceName;
  String optionConnectionUserName;
  String optionConnectionPassword;
  String optionConnectionURL;
  String optionConnectionDriverName;
  String optionConnectionFactoryName;
  Object optionConnectionFactory;
  String optionConnectionFactory2Name;
  Object optionConnectionFactory2;
  boolean optionMultithreaded;
  String optionMapping;
  boolean optionOptimistic;
  boolean optionRetainValues;
  boolean optionRestoreValues;
  boolean optionNontransactionalRead;
  boolean optionNontransactionalWrite;
  boolean optionIgnoreCache;
  boolean optionDetachAllOnCommit;
  boolean optionCopyOnAttach;
  String optionName;
  String optionPersistenceUnitName;
  String optionServerTimeZoneID;
  String optionTransactionType;
  boolean optionReadOnly;
  String optionTransactionIsolationLevel;
  Integer optionDatastoreReadTimeoutMillis;
  Integer optionDatastoreWriteTimeoutMillis;

  final Properties properties = new Properties();

  public String getConnectionUserName() {
    return optionConnectionUserName;
  }

  public void setConnectionUserName(String connectionUserName) {
    this.optionConnectionUserName = connectionUserName;
  }

  public void setConnectionPassword(String connectionPassword) {
    this.optionConnectionPassword = connectionPassword;
  }

  public String getConnectionURL() {
    return optionConnectionURL;
  }

  public void setConnectionURL(String connectionURL) {
    this.optionConnectionURL = connectionURL;
  }

  public String getConnectionDriverName() {
    return optionConnectionDriverName;
  }

  public void setConnectionDriverName(String connectionDriverName) {
    this.optionConnectionDriverName = connectionDriverName;
  }

  public String getConnectionFactoryName() {
    return optionConnectionFactoryName;
  }

  public void setConnectionFactoryName(String connectionFactoryName) {
    this.optionConnectionFactoryName = connectionFactoryName;
  }

  public Object getConnectionFactory() {
    return optionConnectionFactory;
  }

  public void setConnectionFactory(Object connectionFactory) {
    this.optionConnectionFactory = connectionFactory;
  }

  public String getConnectionFactory2Name() {
    return optionConnectionFactory2Name;
  }

  public void setConnectionFactory2Name(String connectionFactory2Name) {
    this.optionConnectionFactory2Name = connectionFactory2Name;
  }

  public Object getConnectionFactory2() {
    return optionConnectionFactory2;
  }

  public void setConnectionFactory2(Object connectionFactory2) {
    this.optionConnectionFactory2 = connectionFactory2;
  }

  public boolean getMultithreaded() {
    return optionMultithreaded;
  }

  public void setMultithreaded(boolean multithreaded) {
    this.optionMultithreaded = multithreaded;
  }

  public String getMapping() {
    return optionMapping;
  }

  public void setMapping(String mapping) {
    this.optionMapping = mapping;
  }

  public boolean getOptimistic() {
    return optionOptimistic;
  }

  public void setOptimistic(boolean optimistic) {
    this.optionOptimistic = optimistic;
  }

  public boolean getRetainValues() {
    return optionRetainValues;
  }

  public void setRetainValues(boolean retainValues) {
    this.optionRetainValues = retainValues;
  }

  public boolean getRestoreValues() {
    return optionRestoreValues;
  }

  public void setRestoreValues(boolean restoreValues) {
    this.optionRestoreValues = restoreValues;
  }

  public boolean getNontransactionalRead() {
    return optionNontransactionalRead;
  }

  public void setNontransactionalRead(boolean nontransactionalRead) {
    this.optionNontransactionalRead = nontransactionalRead;
  }

  public boolean getNontransactionalWrite() {
    return optionNontransactionalWrite;
  }

  public void setNontransactionalWrite(boolean nontransactionalWrite) {
    this.optionNontransactionalWrite = nontransactionalWrite;
  }

  public boolean getIgnoreCache() {
    return optionIgnoreCache;
  }

  public void setIgnoreCache(boolean ignoreCache) {
    this.optionIgnoreCache = ignoreCache;
  }

  public boolean getDetachAllOnCommit() {
    return optionDetachAllOnCommit;
  }

  public void setDetachAllOnCommit(boolean detachAllOnCommit) {
    this.optionDetachAllOnCommit = detachAllOnCommit;
  }

  public boolean getCopyOnAttach() {
    return optionCopyOnAttach;
  }

  public void setCopyOnAttach(boolean copyOnAttach) {
    this.optionCopyOnAttach = copyOnAttach;
  }

  public String getName() {
    return optionName;
  }

  public void setName(String name) {
    this.optionName = name;
  }

  public String getPersistenceUnitName() {
    return optionPersistenceUnitName;
  }

  public void setPersistenceUnitName(String persistenceUnitName) {
    this.optionPersistenceUnitName = persistenceUnitName;
  }

  public String getServerTimeZoneID() {
    return optionServerTimeZoneID;
  }

  public void setServerTimeZoneID(String serverTimeZoneID) {
    this.optionServerTimeZoneID = serverTimeZoneID;
  }

  public String getTransactionType() {
    return optionTransactionType;
  }

  public void setTransactionType(String transactionType) {
    this.optionTransactionType = transactionType;
  }

  public boolean getReadOnly() {
    return optionReadOnly;
  }

  public void setReadOnly(boolean readOnly) {
    this.optionReadOnly = readOnly;
  }

  public String getTransactionIsolationLevel() {
    return optionTransactionIsolationLevel;
  }

  public void setTransactionIsolationLevel(String transactionIsolationLevel) {
    this.optionTransactionIsolationLevel = transactionIsolationLevel;
  }

  public Integer getDatastoreReadTimeoutMillis() {
    return optionDatastoreReadTimeoutMillis;
  }

  public void setDatastoreReadTimeoutMillis(Integer datastoreReadTimeoutMillis) {
    this.optionDatastoreReadTimeoutMillis = datastoreReadTimeoutMillis;
  }

  public Integer getDatastoreWriteTimeoutMillis() {
    return optionDatastoreWriteTimeoutMillis;
  }

  public void setDatastoreWriteTimeoutMillis(Integer datastoreWriteTimeoutMillis) {
    this.optionDatastoreWriteTimeoutMillis = datastoreWriteTimeoutMillis;
  }

  public void close() {
    throw new UnsupportedOperationException("not implemented");
  }

  public boolean isClosed() {
    return true;
  }

  public PersistenceManager getPersistenceManager() {
    throw new UnsupportedOperationException("not implemented");
  }

  public PersistenceManager getPersistenceManagerProxy() {
    throw new UnsupportedOperationException("not implemented");
  }

  public PersistenceManager getPersistenceManager(String userid, String password) {
    throw new UnsupportedOperationException("not implemented");
  }

  public Properties getProperties() {
    return properties;
  }

  public Collection<String> supportedOptions() {
    throw new UnsupportedOperationException("not implemented");
  }

  public DataStoreCache getDataStoreCache() {
    return new DataStoreCache() {

      public void evict(Object oid) {}

      public void evictAll() {}

      public void evictAll(Object... oids) {}

      public void evictAll(Collection<?> oids) {}

      public void evictAll(boolean subclasses, Class<?> pcClass) {}

      public void pin(Object oid) {}

      public void pinAll(Collection<?> oids) {}

      public void pinAll(Object... oids) {}

      public void pinAll(boolean subclasses, Class<?> pcClass) {}

      public void unpin(Object oid) {}

      public void unpinAll(Collection<?> oids) {}

      public void unpinAll(Object... oids) {}

      public void unpinAll(boolean subclasses, Class<?> pcClass) {}
    };
  }

  public void addInstanceLifecycleListener(InstanceLifecycleListener listener, Class<?>[] classes) {
    throw new UnsupportedOperationException("not implemented");
  }

  public void removeInstanceLifecycleListener(InstanceLifecycleListener listener) {
    throw new UnsupportedOperationException("not implemented");
  }

  public void addFetchGroups(FetchGroup... groups) {
    throw new UnsupportedOperationException("not implemented");
  }

  public void removeFetchGroups(FetchGroup... groups) {
    throw new UnsupportedOperationException("not implemented");
  }

  public void removeAllFetchGroups() {
    throw new UnsupportedOperationException("not implemented");
  }

  @SuppressWarnings("rawtypes")
  public FetchGroup getFetchGroup(Class cls, String name) {
    throw new UnsupportedOperationException("not implemented");
  }

  @SuppressWarnings("rawtypes")
  public Set<FetchGroup> getFetchGroups() {
    throw new UnsupportedOperationException("not implemented");
  }

  public void registerMetadata(JDOMetadata metadata) {
    throw new UnsupportedOperationException("not implemented");
  }

  public JDOMetadata newMetadata() {
    throw new UnsupportedOperationException("not implemented");
  }

  public TypeMetadata getMetadata(String className) {
    throw new UnsupportedOperationException("not implemented");
  }

  void setSpiResourceName(String spiPropertiesResourceName) {
    this.spiResourceName = spiPropertiesResourceName;
  }

  public String getSpiPropertiesResourceName() {
    return spiResourceName;
  }

  void setPersistenceManagerFactoryClass(String className) {
    this.persistenceManagerFactoryClassName = className;
  }

  public String getPersistenceManagerFactoryClass() {
    return this.persistenceManagerFactoryClassName;
  }

  void setProperty(String name, Object value) {
    String val = value.toString();

    if (name.equals(PROPERTY_PERSISTENCE_MANAGER_FACTORY_CLASS)) {
      setPersistenceManagerFactoryClass(val);
      return;
    }
    if (name.equals(PROPERTY_CONNECTION_DRIVER_NAME)) {
      setConnectionDriverName(val);
      return;
    }
    if (name.equals(PROPERTY_CONNECTION_FACTORY_NAME)) {
      setConnectionFactoryName(val);
      return;
    }
    if (name.equals(PROPERTY_CONNECTION_FACTORY2_NAME)) {
      setConnectionFactory2Name(val);
      return;
    }
    if (name.equals(PROPERTY_CONNECTION_PASSWORD)) {
      setConnectionPassword(val);
      return;
    }
    if (name.equals(PROPERTY_CONNECTION_URL)) {
      setConnectionURL(val);
      return;
    }
    if (name.equals(PROPERTY_CONNECTION_USER_NAME)) {
      setConnectionUserName(val);
      return;
    }
    if (name.equals(PROPERTY_IGNORE_CACHE)) {
      setCopyOnAttach(Boolean.parseBoolean(val));
      return;
    }
    if (name.equals(PROPERTY_DATASTORE_READ_TIMEOUT_MILLIS)) {
      setDatastoreReadTimeoutMillis(Integer.parseInt(val));
      return;
    }
    if (name.equals(PROPERTY_DATASTORE_WRITE_TIMEOUT_MILLIS)) {
      setDatastoreWriteTimeoutMillis(Integer.parseInt(val));
      return;
    }
    if (name.equals(PROPERTY_DETACH_ALL_ON_COMMIT)) {
      setDetachAllOnCommit(Boolean.parseBoolean(val));
      return;
    }
    if (name.equals(PROPERTY_IGNORE_CACHE)) {
      setIgnoreCache(Boolean.parseBoolean(val));
      return;
    }
    if (name.equals(PROPERTY_MAPPING)) {
      setMapping(val);
      return;
    }
    if (name.equals(PROPERTY_MULTITHREADED)) {
      setMultithreaded(Boolean.parseBoolean(val));
      return;
    }
    if (name.equals(PROPERTY_NAME)) {
      setName(val);
      return;
    }
    if (name.equals(PROPERTY_NONTRANSACTIONAL_READ)) {
      setNontransactionalRead(Boolean.parseBoolean(val));
      return;
    }
    if (name.equals(PROPERTY_NONTRANSACTIONAL_WRITE)) {
      setNontransactionalWrite(Boolean.parseBoolean(val));
      return;
    }
    if (name.equals(PROPERTY_OPTIMISTIC)) {
      setOptimistic(Boolean.parseBoolean(val));
      return;
    }
    if (name.equals(PROPERTY_PERSISTENCE_UNIT_NAME)) {
      setPersistenceUnitName(val);
      return;
    }
    if (name.equals(PROPERTY_READONLY)) {
      setReadOnly(Boolean.parseBoolean(val));
      return;
    }
    if (name.equals(PROPERTY_RESTORE_VALUES)) {
      setRestoreValues(Boolean.parseBoolean(val));
      return;
    }
    if (name.equals(PROPERTY_RETAIN_VALUES)) {
      setRetainValues(Boolean.parseBoolean(val));
      return;
    }
    if (name.equals(PROPERTY_SERVER_TIME_ZONE_ID)) {
      setServerTimeZoneID(val);
      return;
    }
    if (name.equals(PROPERTY_TRANSACTION_ISOLATION_LEVEL)) {
      setTransactionIsolationLevel(val);
      return;
    }
    if (name.equals(PROPERTY_TRANSACTION_TYPE)) {
      setTransactionType(val);
      return;
    }
    if (name.equals(PROPERTY_SPI_RESOURCE_NAME)) {
      setSpiResourceName(val);
      return;
    }

    throw new IllegalArgumentException("unhandled stub PMF property " + name);
  }

  void setProperties(Map<?, ?> properties) {
    for (Object key : properties.keySet()) {
      String k = key.toString();
      Object v = properties.get(key);

      this.properties.put(k, v);
      setProperty(k, v);
    }
  }

  public Collection<Class> getManagedClasses() {
    throw new UnsupportedOperationException("not implemented");
  }
}