using System;
using System.Collections.Generic;
using System.Linq;

using System.Data;
using System.Xml;
using umbraco.cms.businesslogic.property;
using umbraco.cms.businesslogic.propertytype;
using umbraco.DataLayer;
using System.Runtime.CompilerServices;
using umbraco.cms.helpers;
using umbraco.BusinessLogic;
using umbraco.interfaces;
using System.IO;
using umbraco.IO;
using umbraco.cms.businesslogic.datatype.controls;

namespace umbraco.cms.businesslogic
{
    /// <summary>
    /// Content is an intermediate layer between CMSNode and class'es which will use generic data.
    /// 
    /// Content is a datastructure that holds generic data defined in its corresponding ContentType. Content can in some
    /// sence be compared to a row in a database table, it's contenttype hold a definition of the columns and the Content
    /// contains the data
    /// 
    /// Note that Content data in umbraco is *not* tablular but in a treestructure.
    /// 
    /// </summary>
    public class Content : CMSNode
    {
        #region Private Members

        private Guid _version;
        private DateTime _versionDate;
        private XmlNode _xml;
        private bool _versionDateInitialized;
        private string _contentTypeIcon;
        private ContentType _contentType;
        private Properties m_LoadedProperties = null;

        #endregion

        #region Constructors        
      
        public Content(int id) : base(id) { }

        protected Content(int id, bool noSetup) : base(id, noSetup) { }
       
        protected Content(Guid id) : base(id) { }

        protected Content(Guid id, bool noSetup) : base(id, noSetup) { }

        #endregion

        #region Static Methods

        /// <summary>
        /// Retrive a list of Content sharing the ContentType
        /// </summary>
        /// <param name="ct">The ContentType</param>
        /// <returns>A list of Content objects sharing the ContentType defined.</returns>
        public static Content[] getContentOfContentType(ContentType ct)
        {
            IRecordsReader dr = SqlHelper.ExecuteReader("Select nodeId from  cmsContent INNER JOIN umbracoNode ON cmsContent.nodeId = umbracoNode.id where ContentType = " + ct.Id + " ORDER BY umbracoNode.text ");
            System.Collections.ArrayList tmp = new System.Collections.ArrayList();

            while (dr.Read()) tmp.Add(dr.GetInt("nodeId"));
            dr.Close();

            Content[] retval = new Content[tmp.Count];
            for (int i = 0; i < tmp.Count; i++) retval[i] = new Content((int)tmp[i]);

            return retval;
        }

        /// <summary>
        /// Initialize a contentobject given a version.
        /// </summary>
        /// <param name="version">The version identifier</param>
        /// <returns>The Content object from the given version</returns>
        public static Content GetContentFromVersion(Guid version)
        {
            int tmpContentId = SqlHelper.ExecuteScalar<int>("Select ContentId from cmsContentVersion where versionId = '" + version.ToString() + "'");
            return new Content(tmpContentId);
        }

        #endregion

        #region Public Properties

        /// <summary>
        /// The current Content objects ContentType, which defines the Properties of the Content (data)
        /// </summary>
        public ContentType ContentType
        {
            get
            {
                if (_contentType == null)
                {
                    object o = SqlHelper.ExecuteScalar<object>(
                        "Select ContentType from cmsContent where nodeId=@nodeid",
                            SqlHelper.CreateParameter("@nodeid", this.Id));
                    if (o == null)
                        return null;
                    int contentTypeId;
                    if (!int.TryParse(o.ToString(), out contentTypeId))
                        return null;
                    try
                    {
                        _contentType = new ContentType(contentTypeId);
                    }
                    catch
                    {
                        return null;
                    }
                }
                return _contentType;
            }
            set
            {
                _contentType = value;
            }
        }

        /// <summary>
        /// The icon used in the tree - placed in this layer for performance reasons.
        /// </summary>
        /// <remarks>
        /// This is here for performance reasons only. If the _contentTypeIcon is manually set
        /// then a database call is not made to initialize the ContentType.
        /// 
        /// The data layer has slightly changed in 4.1 so that for Document and Media, the ContentType
        /// is automatically initialized with one SQL call when creating the documents/medias so using this
        /// method or the ContentType.IconUrl property when accessing the icon from Media or Document 
        /// won't affect performance.
        /// </remarks>
        public string ContentTypeIcon
        {
            get
            {
                if (_contentTypeIcon == null && this.ContentType != null)
                    _contentTypeIcon = this.ContentType.IconUrl;
                return _contentTypeIcon;
            }
            set
            {
                _contentTypeIcon = value;
            }
        }

        /// <summary>
        /// The createtimestamp on this version
        /// </summary>
        public DateTime VersionDate
        {
            get
            {
                if (!_versionDateInitialized)
                {
                    object o = SqlHelper.ExecuteScalar<object>(
                        "select VersionDate from cmsContentVersion where versionId = '" + this.Version.ToString() + "'");
                    if (o == null)
                    {
                        _versionDate = DateTime.Now;
                    }
                    else
                    {
                        _versionDateInitialized = DateTime.TryParse(o.ToString(), out _versionDate);
                    }
                }
                return _versionDate;
            }
            set
            {
                _versionDate = value;
                _versionDateInitialized = true;
            }
        }

        /// <summary>
        /// Retrieve a list of generic properties of the content
        /// </summary>
        public Properties GenericProperties
        {
            get
            {
                EnsureProperties();
                return m_LoadedProperties;
            }
        }

        /// <summary>
        /// Retrieve a list of generic properties of the content
        /// </summary>
        [Obsolete("Use the GenericProperties property instead")]
        public Property[] getProperties
        {
            get
            {
                EnsureProperties();
                return m_LoadedProperties.ToArray();

                //if (this.ContentType == null)
                //    return new Property[0];

                //List<Property> result = new List<Property>();
                //foreach (PropertyType prop in this.ContentType.PropertyTypes)
                //{
                //    if (prop == null)
                //        continue;
                //    Property p = getProperty(prop);
                //    if (p == null)
                //        continue;
                //    result.Add(p);
                //}

                //return result.ToArray();
            }
        }

        /// <summary>
        /// Content is under version control, you are able to programatically create new versions
        /// </summary>
        public Guid Version
        {
            get
            {
                if (_version == Guid.Empty)
                {
                    string sql = "Select versionId from cmsContentVersion where contentID = " + this.Id +
                                 " order by id desc ";

                    using (IRecordsReader dr = SqlHelper.ExecuteReader(sql))
                    {
                        if (!dr.Read())
                            _version = Guid.Empty;
                        else
                            _version = dr.GetGuid("versionId");
                    }
                }
                return _version;
            }
            set { _version = value; }
        }

        #endregion

        #region Public Methods

        /// <summary>
        /// Used to persist object changes to the database. This ensures that the properties are re-loaded from the database.
        /// </summary>
        public override void Save()
        {            
            base.Save();

            ClearLoadedProperties();
        }

        /// <summary>
        /// Retrieve a Property given the alias
        /// </summary>
        /// <param name="alias">Propertyalias (defined in the documenttype)</param>
        /// <returns>The property with the given alias</returns>
        public Property getProperty(string alias)
        {
            ContentType ct = this.ContentType;
            if (ct == null)
                return null;
            propertytype.PropertyType pt = ct.getPropertyType(alias);
            if (pt == null)
                return null;
            return getProperty(pt);
        }

        /// <summary>
        /// Retrieve a property given the propertytype
        /// </summary>
        /// <param name="pt">PropertyType</param>
        /// <returns>The property with the given propertytype</returns>
        public Property getProperty(PropertyType pt)
        {

            //object o = SqlHelper.ExecuteScalar<object>(
            //    "select id from cmsPropertyData where versionId=@version and propertyTypeId=@propertyTypeId",
            //    SqlHelper.CreateParameter("@version", this.Version),
            //    SqlHelper.CreateParameter("@propertyTypeId", pt.Id));
            //if (o == null)
            //    return null;
            //int propertyId;
            //if (!int.TryParse(o.ToString(), out propertyId))
            //    return null;
            //try
            //{
            //    return new Property(propertyId, pt);
            //}
            //catch (Exception ex)
            //{
            //    Log.Add(LogTypes.Error, this.Id, "An error occurred retreiving property. EXCEPTION: " + ex.Message);
            //    return null;
            //}

            EnsureProperties();

            var prop = m_LoadedProperties
                .Where(x => x.PropertyType.Id == pt.Id)
                .SingleOrDefault();
            return prop;

        }

        /// <summary>
        /// Add a property to the Content
        /// </summary>
        /// <param name="pt">The PropertyType of the Property</param>
        /// <param name="versionId">The version of the document on which the property should be add'ed</param>
        /// <returns>The new Property</returns>
        public Property addProperty(PropertyType pt, Guid versionId)
        {
            ClearLoadedProperties();
            
            return property.Property.MakeNew(pt, this, versionId);

        }

        /// <summary>
        /// An Xmlrepresentation of a Content object.
        /// </summary>
        /// <param name="xd">Xmldocument context</param>
        /// <param name="Deep">If true, the Contents children are appended to the Xmlnode recursive</param>
        /// <returns>The Xmlrepresentation of the data on the Content object</returns>
        public override XmlNode ToXml(XmlDocument xd, bool Deep)
        {
            if (_xml == null)
            {
                XmlDocument xmlDoc = new XmlDocument();
                // we add a try/catch clause here, as the xmlreader will throw an exception if there's no xml in the table
                // after the empty catch we'll generate the xml which is why we don't do anything in the catch part
                try
                {
                    XmlReader xr = SqlHelper.ExecuteXmlReader("select xml from cmsContentXml where nodeID = " + this.Id.ToString());
                    if (xr.MoveToContent() != System.Xml.XmlNodeType.None)
                    {
                        xmlDoc.Load(xr);
                        _xml = xmlDoc.FirstChild;
                    }
                    xr.Close();
                }
                catch
                {
                }


                // Generate xml if xml still null (then it hasn't been initialized before)
                if (_xml == null)
                {
                    this.XmlGenerate(new XmlDocument());
                    _xml = importXml();
                }

            }

            XmlNode x = xd.ImportNode(_xml, true);

            if (Deep)
            {
                var childs = this.Children;
                foreach (BusinessLogic.console.IconI c in childs)
                {
                    try
                    {
                        x.AppendChild(new Content(c.Id).ToXml(xd, true));
                    }
                    catch (Exception mExp)
                    {
                        System.Web.HttpContext.Current.Trace.Warn("Content", "Error adding node to xml: " + mExp.ToString());
                    }
                }
            }

            return x;

        }

        /// <summary>
        /// Removes the Xml cached in the database - unpublish and cleaning
        /// </summary>
        public virtual void XmlRemoveFromDB()
        {
            SqlHelper.ExecuteNonQuery("delete from cmsContentXml where nodeId = @nodeId", SqlHelper.CreateParameter("@nodeId", this.Id));
        }

        /// <summary>
        /// Generates the Content XmlNode
        /// </summary>
        /// <param name="xd"></param>
        public virtual void XmlGenerate(XmlDocument xd)
        {
            XmlNode node = generateXmlWithoutSaving(xd);
            SaveXmlDocument(node);
        }

        public virtual void XmlPopulate(XmlDocument xd, ref XmlNode x, bool Deep)
        {
            var props = this.getProperties;
            foreach (property.Property p in props)
                if (p != null)
                    x.AppendChild(p.ToXml(xd));

            // attributes
            x.Attributes.Append(xmlHelper.addAttribute(xd, "id", this.Id.ToString()));
            x.Attributes.Append(xmlHelper.addAttribute(xd, "version", this.Version.ToString()));
            if (this.Level > 1)
                x.Attributes.Append(xmlHelper.addAttribute(xd, "parentID", this.Parent.Id.ToString()));
            else
                x.Attributes.Append(xmlHelper.addAttribute(xd, "parentID", "-1"));
            x.Attributes.Append(xmlHelper.addAttribute(xd, "level", this.Level.ToString()));
            x.Attributes.Append(xmlHelper.addAttribute(xd, "writerID", this.User.Id.ToString()));
            if (this.ContentType != null)
                x.Attributes.Append(xmlHelper.addAttribute(xd, "nodeType", this.ContentType.Id.ToString()));
            x.Attributes.Append(xmlHelper.addAttribute(xd, "template", "0"));
            x.Attributes.Append(xmlHelper.addAttribute(xd, "sortOrder", this.sortOrder.ToString()));
            x.Attributes.Append(xmlHelper.addAttribute(xd, "createDate", this.CreateDateTime.ToString("s")));
            x.Attributes.Append(xmlHelper.addAttribute(xd, "updateDate", this.VersionDate.ToString("s")));
            x.Attributes.Append(xmlHelper.addAttribute(xd, "nodeName", this.Text));
            if (this.Text != null)
                x.Attributes.Append(xmlHelper.addAttribute(xd, "urlName", this.Text.Replace(" ", "").ToLower()));
            x.Attributes.Append(xmlHelper.addAttribute(xd, "writerName", this.User.Name));
            if (this.ContentType != null)
                x.Attributes.Append(xmlHelper.addAttribute(xd, "nodeTypeAlias", this.ContentType.Alias));
            x.Attributes.Append(xmlHelper.addAttribute(xd, "path", this.Path));

            if (Deep)
            {
                //store children array here because iterating over an Array property object is very inneficient.
                var children = this.Children;
                foreach (Content c in children)
                    x.AppendChild(c.ToXml(xd, true));
            }
        }

        /// <summary>
        /// Deletes the current Content object, must be overridden in the child class.
        /// </summary>
        public override void delete()
        {
            ClearLoadedProperties();

            // Delete all data associated with this content
            this.deleteAllProperties();

            // Remove all content preview xml
            SqlHelper.ExecuteNonQuery("delete from cmsPreviewXml where nodeId = " + Id);

            // Delete version history
            SqlHelper.ExecuteNonQuery("Delete from cmsContentVersion where ContentId = " + this.Id);

            // Delete xml
            SqlHelper.ExecuteNonQuery("delete from cmsContentXml where nodeID = @nodeId", SqlHelper.CreateParameter("@nodeId", this.Id));

            // Delete Contentspecific data ()
            SqlHelper.ExecuteNonQuery("Delete from cmsContent where NodeId = " + this.Id);

            // Delete Nodeinformation!!
            base.delete();
        }

        #endregion

        #region Protected Methods

        /// <summary>
        /// Sets up the ContentType property for this content item and sets the addition content properties manually.
        /// If the ContentType property is not already set, then this will get the ContentType from Cache.
        /// </summary>
        /// <param name="InitContentType"></param>
        /// <param name="InitVersion"></param>
        /// <param name="InitVersionDate"></param>
        /// <param name="InitContentTypeIcon"></param>
        protected void InitializeContent(int InitContentType, Guid InitVersion, DateTime InitVersionDate, string InitContentTypeIcon)
        {
            ClearLoadedProperties();

            if (_contentType == null)
                _contentType = ContentType.GetContentType(InitContentType);
            _version = InitVersion;
            _versionDate = InitVersionDate;
            _contentTypeIcon = InitContentTypeIcon;
        }

        /// <summary>
        /// Creates a new Content object from the ContentType.
        /// </summary>
        /// <param name="ct"></param>
        protected void CreateContent(ContentType ct)
        {
            SqlHelper.ExecuteNonQuery("insert into cmsContent (nodeId,ContentType) values (" + this.Id + "," + ct.Id + ")");
            createNewVersion();
        }



        /// <summary>
        /// Method for creating a new version of the data associated to the Content.
        /// 
        /// </summary>
        /// <returns>The new version Id</returns>
        protected Guid createNewVersion()
        {
            ClearLoadedProperties();

            Guid newVersion = Guid.NewGuid();
            bool tempHasVersion = hasVersion();
            foreach (propertytype.PropertyType pt in this.ContentType.PropertyTypes)
            {
                object oldValue = "";
                if (tempHasVersion)
                {
                    try
                    {
                        oldValue = this.getProperty(pt.Alias).Value;
                    }
                    catch { }
                }
                property.Property p = this.addProperty(pt, newVersion);
                if (oldValue != null && oldValue.ToString() != "") p.Value = oldValue;
            }
            SqlHelper.ExecuteNonQuery("Insert into cmsContentVersion (ContentId,versionId) values (" + this.Id + ",'" + newVersion + "')");
            this.Version = newVersion;
            return newVersion;
        }

        protected virtual XmlNode generateXmlWithoutSaving(XmlDocument xd)
        {
            string nodeName = UmbracoSettings.UseLegacyXmlSchema ? "node" : Casing.SafeAliasWithForcingCheck(ContentType.Alias);
            XmlNode x = xd.CreateNode(XmlNodeType.Element, nodeName, "");
            XmlPopulate(xd, ref x, false);
            return x;
        }

        /// <summary>
        /// Saves the XML document to the data source.
        /// </summary>
        /// <param name="node">The XML Document.</param>
        [MethodImpl(MethodImplOptions.Synchronized)]
        protected virtual void SaveXmlDocument(XmlNode node)
        {
            // Method is synchronized so exists remains consistent (avoiding race condition)
            bool exists = SqlHelper.ExecuteScalar<int>("SELECT COUNT(nodeId) FROM cmsContentXml WHERE nodeId = @nodeId",
                                           SqlHelper.CreateParameter("@nodeId", Id)) > 0;
            string query;
            if (exists)
                query = "UPDATE cmsContentXml SET xml = @xml WHERE nodeId = @nodeId";
            else
                query = "INSERT INTO cmsContentXml(nodeId, xml) VALUES (@nodeId, @xml)";
            SqlHelper.ExecuteNonQuery(query,
                                      SqlHelper.CreateParameter("@nodeId", Id),
                                      SqlHelper.CreateParameter("@xml", node.OuterXml));
        }

        /// <summary>
        /// Deletes all files and the folder that have been saved with this content item which are based on the Upload data
        /// type. This is called when a media or content tree node is deleted. 
        /// </summary>
        protected void DeleteAssociatedMediaFiles()
        {
            // Remove all files
            IDataType uploadField = new Factory().GetNewObject(new Guid("5032a6e6-69e3-491d-bb28-cd31cd11086c"));

            foreach (Property p in GenericProperties)
            {               
                var isUploadField = false;
                try
                {
                    if (p.PropertyType.DataTypeDefinition.DataType.Id == uploadField.Id
                         && p.Value.ToString() != ""
                         && File.Exists(IOHelper.MapPath(p.Value.ToString())))
                    {
                        isUploadField = true;
                    }
                }
                catch (ArgumentException)
                {
                    //the data type definition may not exist anymore at this point because another thread may
                    //have deleted it.
                    isUploadField = false;
                }
                if (isUploadField)
                {                    
                    var fi = new FileInfo(IOHelper.MapPath(p.Value.ToString()));

                    fi.Directory.GetFiles().ToList().ForEach(x =>
                    {
                        x.Delete();
                    });
                    fi.Directory.Delete(true);
                }
            }
        }

        #endregion

        #region Private Methods

        /// <summary>
        /// Clears the locally loaded properties which forces them to be reloaded next time they requested
        /// </summary>
        private void ClearLoadedProperties()
        {
            m_LoadedProperties = null;
        }

        /// <summary>
        /// Makes sure that the properties are initialized. If they are already initialized, this does nothing.
        /// </summary>
        private void EnsureProperties()
        {
            if (m_LoadedProperties == null)
            {
                InitializeProperties();
            }
        }

        /// <summary>
        /// Loads all properties from database into objects. If this method is re-called, it will re-query the database.
        /// </summary>
        /// <remarks>
        /// This optimizes sql calls. This will first check if all of the properties have been loaded. If not, 
        /// then it will query for all property types for the current version from the db. It will then iterate over each
        /// cmdPropertyData row and store the id and propertyTypeId in a list for lookup later. Once the records have been 
        /// read, we iterate over the cached property types for this ContentType and create a new property based on
        /// our stored list of proeprtyTypeIds. We then have a cached list of Property objects which will get returned
        /// on all subsequent calls and is also used to return a property with calls to getProperty.
        /// </remarks>
        private void InitializeProperties()
        {
            m_LoadedProperties = new Properties();

            if (this.ContentType == null)
                return;

            //Create anonymous typed list with 2 props, Id and PropertyTypeId of type Int.
            //This will still be an empty list since the props list is empty.
            var propData = m_LoadedProperties.Select(x => new { Id = 0, PropertyTypeId = 0 }).ToList();

            string sql = @"select id, propertyTypeId from cmsPropertyData where versionId=@versionId";

            using (IRecordsReader dr = SqlHelper.ExecuteReader(sql,
                SqlHelper.CreateParameter("@versionId", Version)))
            {
                while (dr.Read())
                {
                    //add the item to our list
                    propData.Add(new { Id = dr.Get<int>("id"), PropertyTypeId = dr.Get<int>("propertyTypeId") });
                }
            }

            foreach (PropertyType pt in this.ContentType.PropertyTypes)
            {
                if (pt == null)
                    continue;

                //get the propertyId
                var property = propData
                    .Where(x => x.PropertyTypeId == pt.Id)
                    .SingleOrDefault();
                if (property == null)
                    continue;
                var propertyId = property.Id;

                Property p = null;
                try
                {
                    p = new Property(propertyId, pt);
                }
                catch
                {
                    continue; //this remains from old code... not sure why we would do this?
                }

                m_LoadedProperties.Add(p);
            }
        }

        /// <summary>
        /// Optimized method for bulk deletion of properties´on a Content object.
        /// </summary>
        protected void deleteAllProperties()
        {
            SqlHelper.ExecuteNonQuery("Delete from cmsPropertyData where contentNodeId = @nodeId", SqlHelper.CreateParameter("@nodeId", this.Id));
        }

        private XmlNode importXml()
        {
            XmlDocument xmlDoc = new XmlDocument();
            xmlDoc.Load(SqlHelper.ExecuteXmlReader("select xml from cmsContentXml where nodeID = " + this.Id.ToString()));

            return xmlDoc.FirstChild;
        }

        /// <summary>
        /// Indication if the Content exists in at least one version.
        /// </summary>
        /// <returns>Returns true if the Content has a version</returns>
        private bool hasVersion()
        {
            int versionCount = SqlHelper.ExecuteScalar<int>("select Count(Id) as tmp from cmsContentVersion where contentId = " + this.Id.ToString());
            return (versionCount > 0);
        }

        #endregion

        #region XmlPreivew

        public override XmlNode ToPreviewXml(XmlDocument xd)
        {
            if (!PreviewExists(Version))
            {
                saveXmlPreview(xd);
            }
            return GetPreviewXml(xd, Version);
        }

        private void saveXmlPreview(XmlDocument xd)
        {
            SavePreviewXml(generateXmlWithoutSaving(xd), Version);
        }

        #endregion
    }
}