/*
 * 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.
 */

using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Xml;


#pragma warning disable 618

namespace Apache.Geode.Client.FwkLib
{
  using Apache.Geode.DUnitFramework;
  using Apache.Geode.Client.Tests;

  [Serializable]
  public enum DataKind
  {
    String,
    List,
    Region,
    Range,
    Pool
  }

  [Serializable]
  public class FwkLocalFile
  {
    private string m_name;
    private bool m_append;
    private string m_description;
    private string m_content;

    #region Public accessors

    public string Name
    {
      get
      {
        return m_name;
      }
    }

    public bool Append
    {
      get
      {
        return m_append;
      }
    }

    public string Description
    {
      get
      {
        return m_description;
      }
    }

    public string Content
    {
      get
      {
        return m_content;
      }
    }

    #endregion

    public FwkLocalFile(string name, bool append, string description, string content)
    {
      m_name = name;
      m_append = append;
      m_description = description;
      m_content = content;
    }

    public static void LoadLocalFileNodes(XmlNode node)
    {
      XmlNodeList xmlNodes = node.SelectNodes("localFile");
      if (xmlNodes != null)
      {
        foreach (XmlNode lf in xmlNodes)
        {
          XmlAttributeCollection attrcoll = lf.Attributes;
          string name = null;
          bool append = false; ;
          string description = null;
          foreach (XmlAttribute attr in attrcoll)
          {
            // Console.WriteLine("attr name " + attr.Name);
            if (attr.Name == "name")
            {
              name = attr.Name;
            }
            else if (attr.Name == "append")
            {
              if (attr.Value == "true")
              {
                append = true;
              }
              else
              {
                append = false;
              }
            }
            else if (attr.Name == "description")
            {
              description = attr.Value;
            }
            else
            {
              throw new IllegalArgException("Local file data format incorrect");
            }
          }
          FwkLocalFile lfobj = new FwkLocalFile(name, append, description, lf.InnerText);
          Util.BBSet(string.Empty, name, lfobj);
        }
      }
    }
  }

  [Serializable]
  public class FwkData
  {
    #region Private members

    private object m_data1;
    private object m_data2;
    private DataKind m_kind;

    #endregion

    #region Public accessors

    public DataKind Kind
    {
      get
      {
        return m_kind;
      }
    }

    public object Data1
    {
      get
      {
        return m_data1;
      }
      set
      {
        m_data1 = value;
      }
    }
    public object Data2
    {
      get
      {
        return m_data2;
      }
      set
      {
        m_data2 = null;
      }
    }
    #endregion

    public FwkData(object data1, object data2, DataKind kind)
    {
      m_data1 = data1;
      m_data2 = data2;
      m_kind = kind;
    }

    public static Dictionary<string, FwkData> ReadDataNodes(XmlNode node)
    {
    throw new Exception();

    }

    public static void SetThisAttribute(string name, XmlNode node, Apache.Geode.Client.RegionAttributesFactory<string, string> regionAttributesFactory)
    {
      string value = node.Value;
      switch (name)
      {
        case "caching-enabled":
          if (value == "true")
          {
            regionAttributesFactory.SetCachingEnabled(true);
          }
          else
          {
            regionAttributesFactory.SetCachingEnabled(false);
          }
          break;

        case "load-factor":
          float lf = float.Parse(value);
          regionAttributesFactory.SetLoadFactor(lf);
          break;

        case "concurrency-level":
          int cl = int.Parse(value);
          regionAttributesFactory.SetConcurrencyLevel(cl);
          break;

        case "lru-entries-limit":
          uint lel = uint.Parse(value);
          regionAttributesFactory.SetLruEntriesLimit(lel);
          break;

        case "initial-capacity":
          int ic = int.Parse(value);
          regionAttributesFactory.SetInitialCapacity(ic);
          break;

        case "disk-policy":
          if (value == "none")
          {
              regionAttributesFactory.SetDiskPolicy(Apache.Geode.Client.DiskPolicyType.None);
          }
          else if (value == "overflows")
          {
              regionAttributesFactory.SetDiskPolicy(Apache.Geode.Client.DiskPolicyType.Overflows);
          }
          else
          {
            throw new IllegalArgException("Unknown disk policy");
          }
          break;
        case "pool-name":
          if (value.Length != 0)
          {
            regionAttributesFactory.SetPoolName(value);
          }
          else
          {
            regionAttributesFactory.SetPoolName(value);
          }
          break;

        case "client-notification":
          break;

        case "region-time-to-live":
          XmlNode nlrttl = node.FirstChild;
          if (nlrttl.Name == "expiration-attributes")
          {
            XmlAttributeCollection exAttrColl = nlrttl.Attributes;
            Apache.Geode.Client.ExpirationAction action = StrToExpirationAction(exAttrColl["action"].Value);
            string rttl = exAttrColl["timeout"].Value;
            regionAttributesFactory.SetRegionTimeToLive(action, TimeSpan.FromSeconds(uint.Parse(rttl)));
          }
          else
          {
            throw new IllegalArgException("The xml file passed has an unknowk format");
          }
          break;

        case "region-idle-time":
          XmlNode nlrit = node.FirstChild;
          if (nlrit.Name == "expiration-attributes")
          {
            XmlAttributeCollection exAttrColl = nlrit.Attributes;
            Apache.Geode.Client.ExpirationAction action = StrToExpirationAction(exAttrColl["action"].Value);
            string rit = exAttrColl["timeout"].Value;
            regionAttributesFactory.SetRegionIdleTimeout(action, TimeSpan.FromSeconds(uint.Parse(rit)));
          }
          else
          {
            throw new IllegalArgException("The xml file passed has an unknowk format");
          }
          break;

        case "entry-time-to-live":
          XmlNode nlettl = node.FirstChild;
          if (nlettl.Name == "expiration-attributes")
          {
            XmlAttributeCollection exAttrColl = nlettl.Attributes;
            Apache.Geode.Client.ExpirationAction action = StrToExpirationAction(exAttrColl["action"].Value);
            string ettl = exAttrColl["timeout"].Value;
            regionAttributesFactory.SetEntryTimeToLive(action, TimeSpan.FromSeconds(uint.Parse(ettl)));
          }
          else
          {
            throw new IllegalArgException("The xml file passed has an unknowk format");
          }
          break;

        case "entry-idle-time":
          XmlNode nleit = node.FirstChild;
          if (nleit.Name == "expiration-attributes")
          {
            XmlAttributeCollection exAttrColl = nleit.Attributes;
            Apache.Geode.Client.ExpirationAction action = StrToExpirationAction(exAttrColl["action"].Value);
            string eit = exAttrColl["timeout"].Value;
            regionAttributesFactory.SetEntryIdleTimeout(action, TimeSpan.FromSeconds(uint.Parse(eit)));
          }
          else
          {
            throw new IllegalArgException("The xml file passed has an unknowk format");
          }
          break;

        case "cache-loader":
          XmlAttributeCollection loaderattrs = node.Attributes;
          string loaderlibrary = null;
          string loaderfunction = null;
          foreach(XmlAttribute tmpattr in loaderattrs)
          {
            if (tmpattr.Name == "library")
            {
              loaderlibrary = tmpattr.Value;
            }
            else if (tmpattr.Name == "function")
            {
              loaderfunction = tmpattr.Value;
            }
            else
            {
              throw new IllegalArgException("cahe-loader attributes in improper format");
            }
          }
          if (loaderlibrary != null && loaderfunction != null)
          {
            if (loaderfunction.IndexOf('.') < 0)
            {
              Type myType = typeof(FwkData);
              loaderfunction = myType.Namespace + '.' +
                loaderlibrary + '.' + loaderfunction;
              loaderlibrary = "FwkLib";
            }
            regionAttributesFactory.SetCacheLoader(loaderlibrary, loaderfunction);
          }
          break;

        case "cache-listener":
          XmlAttributeCollection listenerattrs = node.Attributes;
          string listenerlibrary = null;
          string listenerfunction = null;
          foreach (XmlAttribute tmpattr in listenerattrs)
          {
            if (tmpattr.Name == "library")
            {
              listenerlibrary = tmpattr.Value;
            }
            else if (tmpattr.Name == "function")
            {
              listenerfunction = tmpattr.Value;
            }
            else
            {
              throw new IllegalArgException("cahe-loader attributes in improper format");
            }
          }
          if (listenerlibrary != null && listenerfunction != null)
          {
            if (listenerfunction.IndexOf('.') < 0)
            {
              Type myType = typeof(FwkData);
              listenerfunction = myType.Namespace + '.' +
                listenerlibrary + '.' + listenerfunction;
              listenerlibrary = "FwkLib";

            }
            regionAttributesFactory.SetCacheListener(listenerlibrary, listenerfunction);
          }
          break;

        case "cache-writer":
          XmlAttributeCollection writerattrs = node.Attributes;
          string writerlibrary = null;
          string writerfunction = null;
          foreach (XmlAttribute tmpattr in writerattrs)
          {
            if (tmpattr.Name == "library")
            {
              writerlibrary = tmpattr.Value;
            }
            else if (tmpattr.Name == "function")
            {
              writerfunction = tmpattr.Value;
            }
            else
            {
              throw new IllegalArgException("cahe-loader attributes in improper format");
            }
          }
          if (writerlibrary != null && writerfunction != null)
          {
            if (writerfunction.IndexOf('.') < 0)
            {
              Type myType = typeof(FwkData);
              writerfunction = myType.Namespace + '.' +
                writerlibrary + '.' + writerfunction;
              writerlibrary = "FwkLib";
            }
            regionAttributesFactory.SetCacheWriter(writerlibrary, writerfunction);
          }
          break;

        case "persistence-manager":
          string pmlibrary = null;
          string pmfunction = null;
          Apache.Geode.Client.Properties<string, string> prop = new Apache.Geode.Client.Properties<string, string>();
          XmlAttributeCollection pmattrs = node.Attributes;
          foreach (XmlAttribute attr in pmattrs)
          {
            if (attr.Name == "library")
            {
              pmlibrary = attr.Value;
            }
            else if (attr.Name == "function")
            {
              pmfunction = attr.Value;
            }
            else
            {
              throw new IllegalArgException("Persistence Manager attributes in wrong format: " + attr.Name);
            }
          }

          if (node.FirstChild.Name == "properties")
          {
            XmlNodeList pmpropnodes = node.FirstChild.ChildNodes;
            foreach (XmlNode propnode in pmpropnodes)
            {
              if (propnode.Name == "property")
              {
                XmlAttributeCollection keyval = propnode.Attributes;
                XmlAttribute keynode = keyval["name"];
                XmlAttribute valnode = keyval["value"];

                if (keynode.Value == "PersistenceDirectory" || keynode.Value == "EnvironmentDirectory")
                {
                  prop.Insert(keynode.Value, valnode.Value);
                }
                else if (keynode.Value == "CacheSizeGb" || keynode.Value == "CacheSizeMb"
                         || keynode.Value == "PageSize" || keynode.Value == "MaxFileSize")
                {
                  prop.Insert(keynode.Value, valnode.Value);
                }
              }
            }
          }
          regionAttributesFactory.SetPersistenceManager(pmlibrary, pmfunction, prop);
          break;
      }
    }

    private static Apache.Geode.Client.ExpirationAction StrToExpirationAction(string str)
    {
        return (Apache.Geode.Client.ExpirationAction)Enum.Parse(typeof(Apache.Geode.Client.ExpirationAction),
        str.Replace("-", string.Empty), true);
    }
  }

  /// <summary>
  /// Reader class for <see cref="FwkData"/>
  /// </summary>
  public class FwkReadData : MarshalByRefObject
  {
    #region Private members

    private Dictionary<string, FwkData> m_dataMap =
      new Dictionary<string, FwkData>();
    private Dictionary<string, int> m_dataIndexMap =
      new Dictionary<string, int>();
    private Stack<string> m_taskNames =
      new Stack<string>();

    #endregion

    #region Private methods

    private FwkData ReadData(string key)
    {
      FwkData data;
      lock (((ICollection)m_dataMap).SyncRoot)
      {
        if (m_dataMap.ContainsKey(key))
        {
          data = m_dataMap[key];
        }
        else
        {
          try
          {
            // First search the task specific data (which overrides the global
            // data) and then search in global data for the key.
            data = Util.BBGet(TaskName, key) as FwkData;
          }
          catch (KeyNotFoundException)
          {
            data = null;
          }
          if (data == null)
          {
            try
            {
              data = Util.BBGet(string.Empty, key) as FwkData;
            }
            catch (KeyNotFoundException)
            {
              data = null;
            }
          }
          m_dataMap[key] = data;
        }
      }
      return data;
    }

    #endregion

    #region Public accessors and constants

    public const string TestRunNumKey = "TestRunNum";
    public const string HostGroupKey = "HostGroup";

    public string TaskName
    {
      get
      {
        return (m_taskNames.Count > 0 ? m_taskNames.Peek() : null);
      }
    }

    #endregion

    #region Public methods

    public void PushTaskName(string taskName)
    {
      m_taskNames.Push(taskName);
      Util.Log("FWKLIB:: Setting the taskname to [{0}]", taskName);
    }

    public void PopTaskName()
    {
      Util.Log("FWKLIB:: Removing taskname [{0}]", TaskName);
      m_taskNames.Pop();
      string oldTaskName = TaskName;
      if (oldTaskName != null)
      {
        Util.Log("FWKLIB:: Setting the taskname back to [{0}]", oldTaskName);
      }
    }

    /// <summary>
    /// Read the value of an object as a string from the server
    /// for the given key.
    /// </summary>
    /// <remarks>
    /// For the case when the key corresponds to a list, this function
    /// gives a random value if the list has 'oneOf' attribute,
    /// else gives the values from the list in sequential order.
    /// </remarks>
    /// <param name="key">The key of the string to read.</param>
    /// <returns>
    /// The string value with the given key; null if not found.
    /// </returns>
    public string GetStringValue(string key)
    {
      FwkData data = ReadData(key);
      string res = null;
      if (data != null)
      {
        if (data.Kind == DataKind.String)
        {
          lock (((ICollection)m_dataIndexMap).SyncRoot)
          {
            int currentIndex;
            if (!m_dataIndexMap.TryGetValue(key, out currentIndex))
            {
              currentIndex = 0;
            }
            if (currentIndex == 0)
            {
              res = data.Data1 as string;
              m_dataIndexMap[key] = 1;
            }
          }
        }
        else if (data.Kind == DataKind.List)
        {
          int len;
          List<string> dataList = data.Data1 as List<string>;
          if (dataList != null && (len = dataList.Count) > 0)
          {
            bool oneOf = false;
            if (data.Data2 != null && data.Data2 is bool)
            {
              oneOf = (bool)data.Data2;
            }
            if (oneOf)
            {
              res = dataList[Util.Rand(len)];
            }
            else
            {
              lock (((ICollection)m_dataIndexMap).SyncRoot)
              {
                int currentIndex;
                if (!m_dataIndexMap.TryGetValue(key, out currentIndex))
                {
                  currentIndex = 0;
                }
                if (currentIndex < len)
                {
                  res = dataList[currentIndex];
                  m_dataIndexMap[key] = currentIndex + 1;
                }
              }
            }
          }
        }
        // TODO: Deal with Range here.
      }
      return res;
    }

    /// <summary>
    /// Read the value of an object as an integer from the server
    /// for the given key.
    /// </summary>
    /// <remarks>
    /// The value is assumed to be an unsigned integer.
    /// For the case when the key corresponds to a list, this function
    /// gives a random value if the list has 'oneOf' attribute,
    /// else gives the values from the list in sequential order.
    /// </remarks>
    /// <param name="key">The key of the string to read.</param>
    /// <returns>
    /// The integer value with the given key; -1 if not found.
    /// </returns>
    public int GetUIntValue(string key)
    {
      string str = GetStringValue(key);
      if (str == null)
      {
        return -1;
      }
      try
      {
        return int.Parse(str);
      }
      catch
      {
        return -1;
      }
    }

    /// <summary>
    /// Read the value of an object as time in seconds from the server
    /// for the given key.
    /// </summary>
    /// <remarks>
    /// If the value contains 'h' or 'm' then it is assumed to be in
    /// hours and minutes respectively.
    /// </remarks>
    /// <param name="key">The key of the value to read.</param>
    /// <returns>
    /// The integer value with the given key; -1 if not found.
    /// </returns>
    public int GetTimeValue(string key)
    {
      return XmlNodeReaderWriter.String2Seconds(GetStringValue(key), -1);
    }

    /// <summary>
    /// Read the value of an object as a boolean value for the given key.
    /// </summary>
    /// <remarks>
    /// If the key is not defined the default value returned is false.
    /// </remarks>
    /// <param name="key">The key of the boolean to read.</param>
    /// <returns>
    /// The boolean value with the given key;
    /// false if not found or in incorrect format.
    /// </returns>
    public bool GetBoolValue(string key)
    {
      string str = GetStringValue(key);
      if (str == null) return false;
      try
      {
        return bool.Parse(str);
      }
      catch
      {
      }
      return false;
    }

    /// <summary>
    /// Read the name of the region for the given key.
    /// </summary>
    /// <param name="key">The key of the region to read.</param>
    /// <returns>The name of the region.</returns>
    public string GetRegionName(string key)
    {
      FwkData data = ReadData(key);
      if (data != null && data.Kind == DataKind.Region)
      {
        return data.Data1 as string;
      }
      return null;
    }


    /// <summary>
    /// Reset a key to the start.
    /// </summary>
    /// <param name="key">The key to remove.</param>
    public void ResetKey(string key)
    {
      lock (((ICollection)m_dataIndexMap).SyncRoot)
      {
        if (m_dataIndexMap.ContainsKey(key))
        {
          m_dataIndexMap.Remove(key);
        }
      }
    }

    /// <summary>
    /// Clear all the keys from the local map.
    /// </summary>
    public void ClearCachedKeys()
    {
      lock (((ICollection)m_dataMap).SyncRoot)
      {
        m_dataMap.Clear();
      }
      lock (((ICollection)m_dataIndexMap).SyncRoot)
      {
        m_dataIndexMap.Clear();
      }
    }

    #endregion
  }
}