// Copyright (c) 2012, Outercurve Foundation.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// - Redistributions of source code must  retain  the  above copyright notice, this
//   list of conditions and the following disclaimer.
//
// - Redistributions in binary form  must  reproduce the  above  copyright  notice,
//   this list of conditions  and  the  following  disclaimer in  the documentation
//   and/or other materials provided with the distribution.
//
// - Neither  the  name  of  the  Outercurve Foundation  nor   the   names  of  its
//   contributors may be used to endorse or  promote  products  derived  from  this
//   software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,  BUT  NOT  LIMITED TO, THE IMPLIED
// WARRANTIES  OF  MERCHANTABILITY   AND  FITNESS  FOR  A  PARTICULAR  PURPOSE  ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL,  SPECIAL,  EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO,  PROCUREMENT  OF  SUBSTITUTE  GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)  HOWEVER  CAUSED AND ON
// ANY  THEORY  OF  LIABILITY,  WHETHER  IN  CONTRACT,  STRICT  LIABILITY,  OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE)  ARISING  IN  ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Data;
using System.IO;
using System.Xml;
using System.Xml.Serialization;
using WebsitePanel.Providers;
using WebsitePanel.Providers.DNS;
using WebsitePanel.Providers.HostedSolution;
using WebsitePanel.Providers.SharePoint;

namespace WebsitePanel.EnterpriseServer.Code.SharePoint
{
    /// <summary>
    /// Exposes handful API on hosted SharePoint site collections management.
    /// </summary>
    public class HostedSharePointServerController : IImportController, IBackupController
    {
        private const int FILE_BUFFER_LENGTH = 5000000; // ~5MB

        /// <summary>
        /// Gets site collections in raw form.
        /// </summary>
        /// <param name="packageId">Package to which desired site collections belong.</param>
        /// <param name="organizationId">Organization to which desired site collections belong.</param>
        /// <param name="filterColumn">Filter column name.</param>
        /// <param name="filterValue">Filter value.</param>
        /// <param name="sortColumn">Sort column name.</param>
        /// <param name="startRow">Row index to start from.</param>
        /// <param name="maximumRows">Maximum number of rows to retrieve.</param>
        /// <returns>Site collections that match.</returns>
        public static SharePointSiteCollectionListPaged GetSiteCollectionsPaged(int packageId, int organizationId, string filterColumn, string filterValue, string sortColumn, int startRow, int maximumRows)
        {
            if (IsDemoMode)
            {
                SharePointSiteCollectionListPaged demoResult = new SharePointSiteCollectionListPaged();
                demoResult.SiteCollections = GetSiteCollections(1, false);
                demoResult.TotalRowCount = demoResult.SiteCollections.Count;
                return demoResult;
            }

            SharePointSiteCollectionListPaged paged = new SharePointSiteCollectionListPaged();
            DataSet result = PackageController.GetRawPackageItemsPaged(packageId, typeof(SharePointSiteCollection),
                true, filterColumn, filterValue, sortColumn, startRow, Int32.MaxValue);
            List<SharePointSiteCollection> items = PackageController.CreateServiceItemsList(result, 1).ConvertAll<SharePointSiteCollection>(delegate(ServiceProviderItem item) { return (SharePointSiteCollection)item; });

            if (organizationId > 0)
            {
                items = items.FindAll(delegate(SharePointSiteCollection siteCollection) { return siteCollection.OrganizationId == organizationId; });
            }
            paged.TotalRowCount = items.Count;

            if (items.Count > maximumRows)
            {
                items.RemoveRange(maximumRows, items.Count - maximumRows);
            }

            paged.SiteCollections = items;

            return paged;
        }

        public static List<SharePointSiteCollection> GetSiteCollections(int organizationId)
        {
            Organization org = OrganizationController.GetOrganization(organizationId);

            List<ServiceProviderItem> items = PackageController.GetPackageItemsByType(org.PackageId, typeof(SharePointSiteCollection), false);
            items.ConvertAll<SharePointSiteCollection>(delegate(ServiceProviderItem item) { return (SharePointSiteCollection)item; });
            List<SharePointSiteCollection> ret = new List<SharePointSiteCollection>();
            foreach (ServiceProviderItem item in items)
            {
                SharePointSiteCollection siteCollection = item as SharePointSiteCollection;
                if (siteCollection != null && siteCollection.OrganizationId == organizationId)
                {
                    ret.Add(siteCollection);
                }
            }

            return ret;
        }

        /// <summary>
        /// Gets list of supported languages by this installation of SharePoint.
        /// </summary>
        /// <returns>List of supported languages</returns>
        public static int[] GetSupportedLanguages(int packageId)
        {
            if (IsDemoMode)
            {
                return new int[] { 1033 };
            }

            // Log operation.
            TaskManager.StartTask("HOSTEDSHAREPOINT", "GET_LANGUAGES");

            int serviceId = PackageController.GetPackageServiceId(packageId, ResourceGroups.HostedSharePoint);
            if (serviceId == 0)
            {
                return new int[] { };
            }

            try
            {
                // Create site collection on server.
                HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(serviceId);
                return hostedSharePointServer.GetSupportedLanguages();
            }
            catch (Exception ex)
            {
                throw TaskManager.WriteError(ex);
            }
            finally
            {
                TaskManager.CompleteTask();
            }
        }

        /// <summary>
        ///  Gets list of SharePoint site collections that belong to the package.
        /// </summary>
        /// <param name="packageId">Package that owns site collections.</param>
        /// <param name="recursive">A value which shows whether nested spaces must be searched as well.</param>
        /// <returns>List of found site collections.</returns>
        public static List<SharePointSiteCollection> GetSiteCollections(int packageId, bool recursive)
        {
            if (IsDemoMode)
            {
                List<SharePointSiteCollection> demoResult = new List<SharePointSiteCollection>();
                SharePointSiteCollection siteCollection1 = new SharePointSiteCollection();
                siteCollection1.Id = 1;
                siteCollection1.OrganizationId = 1;
                siteCollection1.LocaleId = 1033;
                siteCollection1.Name = "http://john.fabrikam.com";
                siteCollection1.OwnerEmail = "john@fabrikam.com";
                siteCollection1.OwnerLogin = "john@fabrikam.com";
                siteCollection1.OwnerName = "John Smith";
                siteCollection1.PhysicalAddress = "http://john.fabrikam.com";
                siteCollection1.Title = "John Smith's Team Site";
                siteCollection1.Url = "http://john.fabrikam.com";
                demoResult.Add(siteCollection1);
                SharePointSiteCollection siteCollection2 = new SharePointSiteCollection();
                siteCollection2.Id = 2;
                siteCollection1.OrganizationId = 1;
                siteCollection2.LocaleId = 1033;
                siteCollection2.Name = "http://mark.contoso.com";
                siteCollection2.OwnerEmail = "mark@contoso.com";
                siteCollection2.OwnerLogin = "mark@contoso.com";
                siteCollection2.OwnerName = "Mark Jonsons";
                siteCollection2.PhysicalAddress = "http://mark.contoso.com";
                siteCollection2.Title = "Mark Jonsons' Blog";
                siteCollection2.Url = "http://mark.contoso.com";
                demoResult.Add(siteCollection2);
                return demoResult;
            }


            List<ServiceProviderItem> items = PackageController.GetPackageItemsByType(packageId, typeof(SharePointSiteCollection), recursive);
            return items.ConvertAll<SharePointSiteCollection>(delegate(ServiceProviderItem item) { return (SharePointSiteCollection)item; });
        }

        /// <summary>
        /// Gets SharePoint site collection with given id.
        /// </summary>
        /// <param name="itemId">Site collection id within metabase.</param>
        /// <returns>Site collection or null in case no such item exist.</returns>
        public static SharePointSiteCollection GetSiteCollection(int itemId)
        {
            if (IsDemoMode)
            {
                return GetSiteCollections(1, false)[itemId - 1];
            }

            SharePointSiteCollection item = PackageController.GetPackageItem(itemId) as SharePointSiteCollection;
            return item;
        }

        /// <summary>
        /// Adds SharePoint site collection.
        /// </summary>
        /// <param name="item">Site collection description.</param>
        /// <returns>Created site collection id within metabase.</returns>
        public static int AddSiteCollection(SharePointSiteCollection item)
        {

            // Check account.
            int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
            if (accountCheck < 0)
            {
                return accountCheck;
            }

            // Check package.
            int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
            if (packageCheck < 0)
            {
                return packageCheck;
            }

            // Check quota.
            OrganizationStatistics orgStats = OrganizationController.GetOrganizationStatistics(item.OrganizationId);
            //QuotaValueInfo quota = PackageController.GetPackageQuota(item.PackageId, Quotas.HOSTED_SHAREPOINT_SITES);

            if (orgStats.AllocatedSharePointSiteCollections > -1
                && orgStats.CreatedSharePointSiteCollections >= orgStats.AllocatedSharePointSiteCollections)
            {
                return BusinessErrorCodes.ERROR_SHAREPOINT_RESOURCE_QUOTA_LIMIT;
            }

            // Check if stats resource is available
            int serviceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.HostedSharePoint);
            if (serviceId == 0)
            {
                return BusinessErrorCodes.ERROR_SHAREPOINT_RESOURCE_UNAVAILABLE;
            }

            StringDictionary hostedSharePointSettings = ServerController.GetServiceSettings(serviceId);
            QuotaValueInfo quota = PackageController.GetPackageQuota(item.PackageId, Quotas.HOSTED_SHAREPOINT_USESHAREDSSL);
            Uri rootWebApplicationUri = new Uri(hostedSharePointSettings["RootWebApplicationUri"]);
            Organization org = OrganizationController.GetOrganization(item.OrganizationId);
            string siteName = item.Name;

            if (quota.QuotaAllocatedValue == 1)
            {
                string sslRoot = hostedSharePointSettings["SharedSSLRoot"];


                string defaultDomain = org.DefaultDomain;
                string hostNameBase = string.Empty;

                string[] tmp = defaultDomain.Split('.');
                if (tmp.Length == 2)
                {
                    hostNameBase = tmp[0];
                }
                else
                {
                    if (tmp.Length > 2)
                    {
                        hostNameBase = tmp[0] + tmp[1];
                    }
                }

                int counter = 0;
                item.Name = String.Format("{0}://{1}", rootWebApplicationUri.Scheme, hostNameBase + "-" + counter.ToString() + "." + sslRoot);
                siteName = String.Format("{0}", hostNameBase + "-" + counter.ToString() + "." + sslRoot);

                while (DataProvider.CheckServiceItemExists(serviceId, item.Name, "WebsitePanel.Providers.SharePoint.SharePointSiteCollection, WebsitePanel.Providers.Base"))
                {
                    counter++;
                    item.Name = String.Format("{0}://{1}", rootWebApplicationUri.Scheme, hostNameBase + "-" + counter.ToString() + "." + sslRoot);
                    siteName = String.Format("{0}", hostNameBase + "-" + counter.ToString() + "." + sslRoot);
                }
            }
            else
                item.Name = String.Format("{0}://{1}", rootWebApplicationUri.Scheme, item.Name);

            if (rootWebApplicationUri.Port > 0 && rootWebApplicationUri.Port != 80 && rootWebApplicationUri.Port != 443)
            {
                item.PhysicalAddress = String.Format("{0}:{1}", item.Name, rootWebApplicationUri.Port);
            }
            else
            {
                item.PhysicalAddress = item.Name;
            }

            if (Utils.ParseBool(hostedSharePointSettings["LocalHostFile"], false))
            {
                item.RootWebApplicationInteralIpAddress = hostedSharePointSettings["RootWebApplicationInteralIpAddress"];
                item.RootWebApplicationFQDN = item.Name.Replace(rootWebApplicationUri.Scheme + "://", "");
            }

            item.MaxSiteStorage = RecalculateMaxSize(org.MaxSharePointStorage, (int)item.MaxSiteStorage);
            item.WarningStorage = item.MaxSiteStorage == -1 ? -1 : Math.Min((int)item.WarningStorage, item.MaxSiteStorage);


            // Check package item with given name already exists.
            if (PackageController.GetPackageItemByName(item.PackageId, item.Name, typeof(SharePointSiteCollection)) != null)
            {
                return BusinessErrorCodes.ERROR_SHAREPOINT_PACKAGE_ITEM_EXISTS;
            }

            // Log operation.
            TaskManager.StartTask("HOSTEDSHAREPOINT", "ADD_SITE_COLLECTION", item.Name);

            try
            {
                // Create site collection on server.
                HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(serviceId);

                hostedSharePointServer.CreateSiteCollection(item);

                // Make record in metabase.
                item.ServiceId = serviceId;
                int itemId = PackageController.AddPackageItem(item);

                hostedSharePointServer.SetPeoplePickerOu(item.Name, org.DistinguishedName);

                int dnsServiceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.Dns);
                if (dnsServiceId > 0)
                {
                    string[] tmpStr = siteName.Split('.');
                    string hostName = tmpStr[0];
                    string domainName = siteName.Substring(hostName.Length + 1, siteName.Length - (hostName.Length + 1));

                    DomainInfo domain = ServerController.GetDomain(domainName);
                    if (domain != null)
                    {
                        string website = siteName;

                        DnsRecord[] records = ServerController.GetDnsZoneRecords(domain.DomainId);
                        foreach (DnsRecord record in records)
                        {
                            if (record.RecordType.Equals(DnsRecordType.A) && (record.RecordName == hostName))
                            {
                                ServerController.DeleteDnsZoneRecord(domain.DomainId, hostName, DnsRecordType.A, record.RecordData);
                                break;
                            }
                        }

                        ServerController.AddDnsZoneRecord(domain.DomainId, hostName, DnsRecordType.A, hostedSharePointSettings["RootWebApplicationIpAddress"], 0, 0, 0, 0);
                    }
                }

                TaskManager.ItemId = itemId;
                return itemId;
            }
            catch (Exception ex)
            {
                throw TaskManager.WriteError(ex);
            }
            finally
            {
                TaskManager.CompleteTask();
            }
        }

        /// <summary>
        /// Deletes SharePoint site collection with given id.
        /// </summary>
        /// <param name="itemId">Site collection id within metabase.</param>
        /// <returns>?</returns>
        public static int DeleteSiteCollection(int itemId)
        {
            // Check account.
            int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
            if (accountCheck < 0)
            {
                return accountCheck;
            }

            // Load original meta item
            SharePointSiteCollection origItem = (SharePointSiteCollection)PackageController.GetPackageItem(itemId);
            if (origItem == null)
            {
                return BusinessErrorCodes.ERROR_SHAREPOINT_PACKAGE_ITEM_NOT_FOUND;
            }

            // Get service settings.
            StringDictionary hostedSharePointSettings = ServerController.GetServiceSettings(origItem.ServiceId);
            Uri rootWebApplicationUri = new Uri(hostedSharePointSettings["RootWebApplicationUri"]);
            string siteName = origItem.Name.Replace(String.Format("{0}://", rootWebApplicationUri.Scheme), String.Empty);

            // Log operation.
            TaskManager.StartTask("HOSTEDSHAREPOINT", "DELETE_SITE", origItem.Name);
            TaskManager.ItemId = itemId;

            try
            {
                // Delete site collection on server.
                HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(origItem.ServiceId);
                hostedSharePointServer.DeleteSiteCollection(origItem);
                // Delete record in metabase.
                PackageController.DeletePackageItem(origItem.Id);

                int dnsServiceId = PackageController.GetPackageServiceId(origItem.PackageId, ResourceGroups.Dns);
                if (dnsServiceId > 0)
                {
                    string[] tmpStr = siteName.Split('.');
                    string hostName = tmpStr[0];
                    string domainName = siteName.Substring(hostName.Length + 1, siteName.Length - (hostName.Length + 1));

                    DomainInfo domain = ServerController.GetDomain(domainName);
                    if (domain != null)
                    {
                        ServerController.DeleteDnsZoneRecord(domain.DomainId, hostName, DnsRecordType.A, hostedSharePointSettings["RootWebApplicationIpAddress"]);
                    }
                }

                return 0;
            }
            catch (Exception ex)
            {
                throw TaskManager.WriteError(ex);
            }
            finally
            {
                TaskManager.CompleteTask();
            }
        }

        /// <summary>
        /// Deletes SharePoint site collections which belong to organization.
        /// </summary>
        /// <param name="organizationId">Site collection id within metabase.</param>
        public static void DeleteSiteCollections(int organizationId)
        {
            Organization org = OrganizationController.GetOrganization(organizationId);
            SharePointSiteCollectionListPaged existentSiteCollections = GetSiteCollectionsPaged(org.PackageId, org.Id, String.Empty, String.Empty, String.Empty, 0, Int32.MaxValue);
            foreach (SharePointSiteCollection existentSiteCollection in existentSiteCollections.SiteCollections)
            {
                DeleteSiteCollection(existentSiteCollection.Id);
            }
        }

        /// <summary>
        /// Backups SharePoint site collection.
        /// </summary>
        /// <param name="itemId">Site collection id within metabase.</param>
        /// <param name="fileName">Backed up site collection file name.</param>
        /// <param name="zipBackup">A value which shows whether back up must be archived.</param>
        /// <param name="download">A value which shows whether created back up must be downloaded.</param>
        /// <param name="folderName">Local folder to store downloaded backup.</param>
        /// <returns>Created backup file name. </returns>
        public static string BackupSiteCollection(int itemId, string fileName, bool zipBackup, bool download, string folderName)
        {
            // Check account.
            int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
            if (accountCheck < 0)
            {
                return null;
            }

            // Load original meta item
            SharePointSiteCollection origItem = (SharePointSiteCollection)PackageController.GetPackageItem(itemId);
            if (origItem == null)
            {
                return null;
            }

            // Log operation.
            TaskManager.StartTask("HOSTEDSHAREPOINT", "BACKUP_SITE_COLLECTION", origItem.Name);
            TaskManager.ItemId = itemId;

            try
            {
                // Create site collection on server.
                HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(origItem.ServiceId);
                string backFile = hostedSharePointServer.BackupSiteCollection(origItem.Name, fileName, zipBackup);

                if (!download)
                {
                    // Copy backup files to space folder.
                    string relFolderName = FilesController.CorrectRelativePath(folderName);
                    if (!relFolderName.EndsWith("\\"))
                    {
                        relFolderName = relFolderName + "\\";
                    }

                    // Create backup folder if not exists
                    if (!FilesController.DirectoryExists(origItem.PackageId, relFolderName))
                    {
                        FilesController.CreateFolder(origItem.PackageId, relFolderName);
                    }

                    string packageFile = relFolderName + Path.GetFileName(backFile);

                    // Delete destination file if exists
                    if (FilesController.FileExists(origItem.PackageId, packageFile))
                    {
                        FilesController.DeleteFiles(origItem.PackageId, new string[] { packageFile });
                    }

                    byte[] buffer = null;

                    int offset = 0;
                    do
                    {
                        // Read remote content.
                        buffer = hostedSharePointServer.GetTempFileBinaryChunk(backFile, offset, FILE_BUFFER_LENGTH);

                        // Write remote content.
                        FilesController.AppendFileBinaryChunk(origItem.PackageId, packageFile, buffer);

                        offset += FILE_BUFFER_LENGTH;
                    }
                    while (buffer.Length == FILE_BUFFER_LENGTH);
                }

                return backFile;
            }
            catch (Exception ex)
            {
                throw TaskManager.WriteError(ex);
            }
            finally
            {
                TaskManager.CompleteTask();
            }
        }

        /// <summary>
        /// Restores SharePoint site collection.
        /// </summary>
        /// <param name="itemId">Site collection id within metabase.</param>
        /// <param name="uploadedFile"></param>
        /// <param name="packageFile"></param>
        /// <returns></returns>
        public static int RestoreSiteCollection(int itemId, string uploadedFile, string packageFile)
        {
            // Check account.
            int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
            if (accountCheck < 0)
            {
                return accountCheck;
            }

            // Load original meta item.
            SharePointSiteCollection origItem = (SharePointSiteCollection)PackageController.GetPackageItem(itemId);
            if (origItem == null)
            {
                return BusinessErrorCodes.ERROR_SHAREPOINT_PACKAGE_ITEM_NOT_FOUND;
            }

            // Check package.
            int packageCheck = SecurityContext.CheckPackage(origItem.PackageId, DemandPackage.IsActive);
            if (packageCheck < 0)
            {
                return packageCheck;
            }

            // Log operation.
            TaskManager.StartTask("HOSTEDSHAREPOINT", "BACKUP_SITE_COLLECTION", origItem.Name);
            TaskManager.ItemId = itemId;

            try
            {
                // Create site collection on server.
                HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(origItem.ServiceId);

                string backupFile = null;
                if (!String.IsNullOrEmpty(packageFile))
                {
                    // Copy package files to the remote SharePoint Server.
                    string path = null;
                    byte[] buffer = null;

                    int offset = 0;
                    do
                    {
                        // Read package file.
                        buffer = FilesController.GetFileBinaryChunk(origItem.PackageId, packageFile, offset, FILE_BUFFER_LENGTH);

                        // Write remote backup file
                        string tempPath = hostedSharePointServer.AppendTempFileBinaryChunk(Path.GetFileName(packageFile), path, buffer);
                        if (path == null)
                        {
                            path = tempPath;
                            backupFile = path;
                        }

                        offset += FILE_BUFFER_LENGTH;
                    }
                    while (buffer.Length == FILE_BUFFER_LENGTH);
                }
                else if (!String.IsNullOrEmpty(uploadedFile))
                {
                    // Upladed files.
                    backupFile = uploadedFile;
                }

                // Restore.
                if (!String.IsNullOrEmpty(backupFile))
                {
                    hostedSharePointServer.RestoreSiteCollection(origItem, backupFile);
                }

                return 0;
            }
            catch (Exception ex)
            {
                throw TaskManager.WriteError(ex);
            }
            finally
            {
                TaskManager.CompleteTask();
            }
        }

        /// <summary>
        /// Gets binary data chunk of specified size from specified offset.
        /// </summary>
        /// <param name="itemId">Item id to obtain realted service id.</param>
        /// <param name="path">Path to file to get bunary data chunk from.</param>
        /// <param name="offset">Offset from which to start data reading.</param>
        /// <param name="length">Binary data chunk length.</param>
        /// <returns>Binary data chunk read from file.</returns>
        public static byte[] GetBackupBinaryChunk(int itemId, string path, int offset, int length)
        {
            // Load original meta item.
            SharePointSiteCollection item = (SharePointSiteCollection)PackageController.GetPackageItem(itemId);
            if (item == null)
            {
                return null;
            }

            HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(item.ServiceId);
            return hostedSharePointServer.GetTempFileBinaryChunk(path, offset, length);
        }

        /// <summary>
        /// Appends supplied binary data chunk to file.
        /// </summary>
        /// <param name="itemId">Item id to obtain realted service id.</param>
        /// <param name="fileName">Non existent file name to append to.</param>
        /// <param name="path">Full path to existent file to append to.</param>
        /// <param name="chunk">Binary data chunk to append to.</param>
        /// <returns>Path to file that was appended with chunk.</returns>
        public static string AppendBackupBinaryChunk(int itemId, string fileName, string path, byte[] chunk)
        {
            // Load original meta item.
            SharePointSiteCollection item = (SharePointSiteCollection)PackageController.GetPackageItem(itemId);
            if (item == null)
            {
                return null;
            }

            HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(item.ServiceId);
            return hostedSharePointServer.AppendTempFileBinaryChunk(fileName, path, chunk);
        }

        /// <summary>
        /// Initializes a new hosted SharePoint server proxy.
        ///  </summary>
        /// <param name="serviceId">Hosted SharePoint service id.</param>
        /// <returns>Hosted SharePoint server proxy.</returns>
        private static HostedSharePointServer GetHostedSharePointServer(int serviceId)
        {

            HostedSharePointServer sps = new HostedSharePointServer();
            ServiceProviderProxy.Init(sps, serviceId);
            return sps;
        }

        /// <summary>
        /// Gets list of importable items.
        /// </summary>
        /// <param name="packageId">Package that owns importable items.</param>
        /// <param name="itemTypeId">Item type id.</param>
        /// <param name="itemType">Item type.</param>
        /// <param name="group">Item resource group.</param>
        /// <returns>List of importable item names.</returns>
        public List<string> GetImportableItems(int packageId, int itemTypeId, Type itemType, ResourceGroupInfo group)
        {
            List<string> items = new List<string>();

            // Get service id
            int serviceId = PackageController.GetPackageServiceId(packageId, group.GroupName);
            if (serviceId == 0)
            {
                return items;
            }

            HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(serviceId);
            if (itemType == typeof(SharePointSiteCollection))
            {
                foreach (SharePointSiteCollection siteCollection in hostedSharePointServer.GetSiteCollections())
                {
                    items.Add(siteCollection.Url);
                }
            }

            return items;
        }

        /// <summary>
        /// Imports selected item into metabase.
        /// </summary>
        /// <param name="packageId">Package to which items must be imported.</param>
        /// <param name="itemTypeId">Item type id.</param>
        /// <param name="itemType">Item type.</param>
        /// <param name="group">Item resource group.</param>
        /// <param name="itemName">Item name to import.</param>
        public void ImportItem(int packageId, int itemTypeId, Type itemType, ResourceGroupInfo group, string itemName)
        {
            // Get service id
            int serviceId = PackageController.GetPackageServiceId(packageId, group.GroupName);
            if (serviceId == 0)
            {
                return;
            }

            HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(serviceId);
            if (itemType == typeof(SharePointSiteCollection))
            {
                SharePointSiteCollection siteCollection = hostedSharePointServer.GetSiteCollection(itemName);
                PackageController.AddPackageItem(siteCollection);
            }
        }

        /// <summary>
        /// Backups service item by serializing it into supplied writer.
        /// </summary>
        /// <param name="tempFolder">Temporary directory path.</param>
        /// <param name="writer">Xml wirter used to store backuped service provider items.</param>
        /// <param name="item">Service provider item to be backed up..</param>
        /// <param name="group">Service provider resource group.</param>
        /// <returns>Resulting code.</returns>
        public int BackupItem(string tempFolder, XmlWriter writer, ServiceProviderItem item, ResourceGroupInfo group)
        {
            SharePointSiteCollection siteCollection = item as SharePointSiteCollection;
            if (siteCollection != null)
            {
                HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(siteCollection.ServiceId);
                SharePointSiteCollection loadedSiteCollection = hostedSharePointServer.GetSiteCollection(siteCollection.Url);
                // Update item
                siteCollection.Url = loadedSiteCollection.Url;
                siteCollection.OwnerLogin = loadedSiteCollection.OwnerLogin;
                siteCollection.OwnerName = loadedSiteCollection.OwnerName;
                siteCollection.OwnerEmail = loadedSiteCollection.OwnerEmail;
                siteCollection.LocaleId = loadedSiteCollection.LocaleId;
                siteCollection.Title = loadedSiteCollection.Title;
                siteCollection.Description = loadedSiteCollection.Description;
                // Serialize it.
                XmlSerializer serializer = new XmlSerializer(typeof(SharePointSiteCollection));
                serializer.Serialize(writer, siteCollection);

            }
            return 0;
        }

        /// <summary>
        /// Restore backed up previously service provider item.
        /// </summary>
        /// <param name="tempFolder">Temporary directory path.</param>
        /// <param name="itemNode">Serialized service provider item.</param>
        /// <param name="itemId">Service provider item id.</param>
        /// <param name="itemType">Service provider item type.</param>
        /// <param name="itemName">Service provider item name.</param>
        /// <param name="packageId">Service provider item package.</param>
        /// <param name="serviceId">Service provider item service id.</param>
        /// <param name="group">Service provider item resource group.</param>
        /// <returns>Resulting code.</returns>
        public int RestoreItem(string tempFolder, XmlNode itemNode, int itemId, Type itemType, string itemName, int packageId, int serviceId, ResourceGroupInfo group)
        {
            if (itemType == typeof(SharePointSiteCollection))
            {
                HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(serviceId);
                // Deserialize item.								                 
                XmlSerializer serializer = new XmlSerializer(typeof(SharePointSiteCollection));
                SharePointSiteCollection siteCollection = (SharePointSiteCollection)serializer.Deserialize(new XmlNodeReader(itemNode.SelectSingleNode("SharePointSiteCollection")));
                siteCollection.PackageId = packageId;
                siteCollection.ServiceId = serviceId;

                // Create site collection if needed.
                if (hostedSharePointServer.GetSiteCollection(siteCollection.Url) == null)
                {
                    hostedSharePointServer.CreateSiteCollection(siteCollection);
                }

                // Add metabase record if needed.
                SharePointSiteCollection metaSiteCollection = (SharePointSiteCollection)PackageController.GetPackageItemByName(packageId, itemName, typeof(SharePointSiteCollection));
                if (metaSiteCollection == null)
                {
                    PackageController.AddPackageItem(siteCollection);
                }
            }

            return 0;
        }


        private static int GetHostedSharePointServiceId(int packageId)
        {
            return PackageController.GetPackageServiceId(packageId, ResourceGroups.HostedSharePoint);
        }

        private static List<SharePointSiteCollection> GetOrganizationSharePointSiteCollections(int orgId)
        {
            Organization org = OrganizationController.GetOrganization(orgId);

            SharePointSiteCollectionListPaged siteCollections = GetSiteCollectionsPaged(org.PackageId, org.Id, String.Empty, String.Empty, String.Empty, 0, Int32.MaxValue);
            return siteCollections.SiteCollections;
        }

        private static int RecalculateStorageMaxSize(int size, int packageId)
        {
            PackageContext cntx = PackageController.GetPackageContext(packageId);
            QuotaValueInfo quota = cntx.Quotas[Quotas.HOSTED_SHAREPOINT_STORAGE_SIZE];

            if (quota.QuotaAllocatedValue == -1)
            {
                if (size == -1)//Unlimited 
                    return -1;
                else
                    return size;
            }
            else
            {
                if (size == -1)
                    return quota.QuotaAllocatedValue;

                return Math.Min(size, quota.QuotaAllocatedValue);
            }
        }

        private static int RecalculateMaxSize(int parentSize, int realSize)
        {
            if (parentSize == -1)
            {
                if (realSize == -1 || realSize == 0)
                    return -1;
                else
                    return realSize;
            }


            if (realSize == -1 || realSize == 0)
                return parentSize;

            return Math.Min(parentSize, realSize);

        }


        public static int SetStorageSettings(int itemId, int maxStorage, int warningStorage, bool applyToSiteCollections)
        {
            // check account
            int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
            if (accountCheck < 0) return accountCheck;

            // place log record
            TaskManager.StartTask("HOSTED_SHAREPOINT", "SET_ORG_LIMITS");
            TaskManager.ItemId = itemId;

            try
            {
                Organization org = (Organization)PackageController.GetPackageItem(itemId);
                if (org == null)
                    return 0;

                // set limits
                int realMaxSizeValue = RecalculateStorageMaxSize(maxStorage, org.PackageId);

                org.MaxSharePointStorage = realMaxSizeValue;

                org.WarningSharePointStorage = realMaxSizeValue == -1 ? -1 : Math.Min(warningStorage, realMaxSizeValue);

                // save organization
                UpdateOrganization(org);

                if (applyToSiteCollections)
                {
                    int serviceId = GetHostedSharePointServiceId(org.PackageId);

                    HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(serviceId);

                    List<SharePointSiteCollection> currentOrgSiteCollection =
                        GetOrganizationSharePointSiteCollections(org.Id);


                    foreach (SharePointSiteCollection siteCollection in currentOrgSiteCollection)
                    {
                        try
                        {
                            SharePointSiteCollection sc = GetSiteCollection(siteCollection.Id);
                            sc.MaxSiteStorage = realMaxSizeValue;
                            sc.WarningStorage = realMaxSizeValue == -1 ? -1 : warningStorage;
                            PackageController.UpdatePackageItem(sc);

                            hostedSharePointServer.UpdateQuotas(siteCollection.PhysicalAddress, realMaxSizeValue,
                                                                warningStorage);
                        }
                        catch (Exception ex)
                        {
                            TaskManager.WriteError(ex);
                        }
                    }
                }

                return 0;
            }
            catch (Exception ex)
            {
                throw TaskManager.WriteError(ex);
            }
            finally
            {
                TaskManager.CompleteTask();
            }
        }

        public static SharePointSiteDiskSpace[] CalculateSharePointSitesDiskSpace(int itemId, out int errorCode)
        {
            SharePointSiteDiskSpace[] retDiskSpace = null;
            errorCode = 0;
            // check account
            int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
            if (accountCheck < 0)
            {
                errorCode = accountCheck;
                return null;
            }

            // place log record
            TaskManager.StartTask("HOSTED_SHAREPOINT", "CALCULATE_DISK_SPACE");
            TaskManager.ItemId = itemId;
            try
            {
                Organization org = (Organization)PackageController.GetPackageItem(itemId);
                if (org == null)
                    return null;

                int serviceId = GetHostedSharePointServiceId(org.PackageId);

                HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(serviceId);

                List<SharePointSiteCollection> currentOrgSiteCollection =
                    GetOrganizationSharePointSiteCollections(org.Id);

                List<string> urls = new List<string>();
                foreach (SharePointSiteCollection siteCollection in currentOrgSiteCollection)
                {
                    urls.Add(siteCollection.PhysicalAddress);
                }
                if (urls.Count > 0)
                    retDiskSpace = hostedSharePointServer.CalculateSiteCollectionsDiskSpace(urls.ToArray());
                else
                {
                    retDiskSpace = new SharePointSiteDiskSpace[1];
                    retDiskSpace[0] = new SharePointSiteDiskSpace();
                    retDiskSpace[0].DiskSpace = 0;
                    retDiskSpace[0].Url = string.Empty;
                }
            }
            catch (Exception ex)
            {
                throw TaskManager.WriteError(ex);
            }
            finally
            {
                TaskManager.CompleteTask();
            }
            return retDiskSpace;
        }

        private static void UpdateOrganization(Organization organization)
        {
            PackageController.UpdatePackageItem(organization);
        }


        public static void UpdateQuota(int itemId, int siteCollectionId, int maxStorage, int warningStorage)
        {
            TaskManager.StartTask("HOSTED_SHAREPOINT", "UPDATE_QUOTA");
            try
            {
                Organization org = (Organization)PackageController.GetPackageItem(itemId);
                if (org == null)
                    return;

                int serviceId = GetHostedSharePointServiceId(org.PackageId);

                HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(serviceId);

                SharePointSiteCollection sc = GetSiteCollection(siteCollectionId);

                int maxSize = RecalculateMaxSize(org.MaxSharePointStorage, maxStorage);
                int warningSize = warningStorage;


                sc.MaxSiteStorage = maxSize;
                sc.WarningStorage = maxSize == -1 ? -1 : Math.Min(warningSize, maxSize);
                PackageController.UpdatePackageItem(sc);

                hostedSharePointServer.UpdateQuotas(sc.PhysicalAddress, maxSize,
                                                    warningStorage);
            }
            catch (Exception ex)
            {
                throw TaskManager.WriteError(ex);
            }
            finally
            {
                TaskManager.CompleteTask();
            }
        }
        /// <summary>
        /// Gets a value if caller is in demo mode.
        /// </summary>
        private static bool IsDemoMode
        {
            get
            {
                return (SecurityContext.CheckAccount(DemandAccount.NotDemo) < 0);
            }
        }
    }
}