//-----------------------------------------------------------------------
// <copyright file="ModelFactory.cs" company="Takayoshi Matsuyama">
//     Copyright (c) Takayoshi Matsuyama. All rights reserved.
// </copyright>
//-----------------------------------------------------------------------

// This file is part of Simple Backup.
//
// Simple Backup is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Simple Backup is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Simple Backup.  If not, see <http://www.gnu.org/licenses/>.

namespace SimpleBackup.Models
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Xml.Linq;
    using SimpleBackup.Core.Models;

    /// <summary>
    /// Creates model objectrs.
    /// </summary>
    internal class ModelFactory : IModelFactory
    {
        /// <summary>
        /// Creates the backup setting.
        /// </summary>
        /// <returns>
        /// The backup setting.
        /// </returns>
        public IBackupSetting CreateBackupSetting()
        {
            return new BackupSetting();
        }

        /// <summary>
        /// Creates the backup setting.
        /// </summary>
        /// <param name="settingFileName">Name of the setting file.</param>
        /// <param name="backupInfoCollection">The backup information collection.</param>
        /// <returns>
        /// The backup setting.
        /// </returns>
        public IBackupSetting CreateBackupSetting(
            string settingFileName,
            IEnumerable<IBackupInfo> backupInfoCollection)
        {
            return new BackupSetting(settingFileName, backupInfoCollection);
        }

        /// <summary>
        /// Creates the backup information.
        /// </summary>
        /// <returns>
        /// The backup inforamtion.
        /// </returns>
        public IBackupInfo CreateBackupInfo()
        {
            return new BackupInfo();
        }

        /// <summary>
        /// Creates the backup information.
        /// </summary>
        /// <param name="sourceBackupInfo">The source backup information.</param>
        /// <returns>
        /// The backup inforamtion.
        /// </returns>
        public IBackupInfo CreateBackupInfo(IBackupInfo sourceBackupInfo)
        {
            return new BackupInfo(sourceBackupInfo);
        }

        /// <summary>
        /// Creates the backup information.
        /// </summary>
        /// <param name="label">The label.</param>
        /// <param name="backupSourceType">Type of the backup source.</param>
        /// <param name="isEnabled">if set to <c>true</c> [is enabled].</param>
        /// <param name="isZipArchive">if set to <c>true</c> [is zip archive].</param>
        /// <param name="sourcePath">The source path.</param>
        /// <param name="destinationFolderPath">The destination folder path.</param>
        /// <returns>
        /// The backup inforamtion.
        /// </returns>
        public IBackupInfo CreateBackupInfo(
            string label,
            BackupSourceType backupSourceType,
            bool isEnabled,
            bool isZipArchive,
            string sourcePath,
            string destinationFolderPath)
        {
            return new BackupInfo(
                label,
                backupSourceType,
                isEnabled,
                isZipArchive,
                sourcePath,
                destinationFolderPath);
        }

        /// <summary>
        /// Creates the backup information.
        /// </summary>
        /// <param name="id">The identifier.</param>
        /// <param name="label">The label.</param>
        /// <param name="backupSourceType">Type of the backup source.</param>
        /// <param name="isEnabled">if set to <c>true</c> [is enabled].</param>
        /// <param name="isZipArchive">if set to <c>true</c> [is zip archive].</param>
        /// <param name="sourcePath">The source path.</param>
        /// <param name="destinationFolderPath">The destination folder path.</param>
        /// <returns>
        /// The backup inforamtion.
        /// </returns>
        public IBackupInfo CreateBackupInfo(
            Guid id,
            string label,
            BackupSourceType backupSourceType,
            bool isEnabled,
            bool isZipArchive,
            string sourcePath,
            string destinationFolderPath)
        {
            return new BackupInfo(
                id,
                label,
                backupSourceType,
                isEnabled,
                isZipArchive,
                sourcePath,
                destinationFolderPath);
        }

        /// <summary>
        /// Creates the backup information from binary.
        /// </summary>
        /// <param name="binaryData">The binary data.</param>
        /// <param name="copySuffixNeeded">if set to <c>true</c> copy suffix is needed.</param>
        /// <returns>
        /// The backup inforamtion.
        /// </returns>
        public IBackupInfo CreateBackupInfoFromBinary(byte[] binaryData, bool copySuffixNeeded)
        {
            return BackupInfo.FromBinary(binaryData, copySuffixNeeded);
        }

        /// <summary>
        /// Creates the result information.
        /// </summary>
        /// <param name="category">The category.</param>
        /// <param name="description">The description.</param>
        /// <returns>
        /// The result inforamtion.
        /// </returns>
        public IResultInfo CreateResultInfo(BackupState category, string description)
        {
            return new ResultInfo(category, description);
        }

        /// <summary>
        /// Creates the destination path information.
        /// </summary>
        /// <param name="backupSourceType">Type of the backup source.</param>
        /// <param name="path">The path.</param>
        /// <returns>
        /// The destination path information.
        /// </returns>
        public IDestinationPathInfo CreateDestinationPathInfo(BackupSourceType backupSourceType, string path)
        {
            return new DestinationPathInfo(backupSourceType, path);
        }

        /// <summary>
        /// Restores the backup setting from XML.
        /// </summary>
        /// <param name="xml">The XML.</param>
        /// <param name="fileName">Name of the file.</param>
        /// <returns>The restored backup setting.</returns>
        public IBackupSetting RestoreBackupSettingFromXml(XElement xml, string fileName)
        {
            if (xml.Name != "BackupSetting")
            {
                return null;
            }

            XElement itemsElement = xml.Elements("Items").FirstOrDefault();
            if (itemsElement == null)
            {
                return null;
            }

            var backupInfoList = new List<IBackupInfo>();
            foreach (XElement element in itemsElement.Elements())
            {
                IBackupInfo backupInfo = RestoreBackupInfoFromXml(element);
                backupInfoList.Add(backupInfo);
            }

            return new BackupSetting(fileName, backupInfoList);
        }

        /// <summary>
        /// Restores the backup information from XML.
        /// </summary>
        /// <param name="xml">The XML.</param>
        /// <returns>The restored backup information.</returns>
        private static IBackupInfo RestoreBackupInfoFromXml(XElement xml)
        {
            if (xml.Name != "BackupInfo")
            {
                return null;
            }

            XElement idElement = xml.Elements("Id").FirstOrDefault();
            XElement labelElement = xml.Elements("Label").FirstOrDefault();
            XElement backupSourceTypeElement = xml.Elements("BackupSourceType").FirstOrDefault();
            XElement enabledElement = xml.Elements("IsEnabled").FirstOrDefault();
            XElement zipArchiveElement = xml.Elements("IsZipArchive").FirstOrDefault();
            XElement sourcePathElement = xml.Elements("SourcePath").FirstOrDefault();
            XElement destinationFolderPathElement = xml.Elements("DestinationFolderPath").FirstOrDefault();

            if ((idElement == null) ||
                (labelElement == null) ||
                (backupSourceTypeElement == null) ||
                (enabledElement == null) ||
                (zipArchiveElement == null) ||
                (sourcePathElement == null) ||
                (destinationFolderPathElement == null))
            {
                return null;
            }

            Guid id;
            if (Guid.TryParse(idElement.Value, out id) == false)
            {
                return null;
            }

            BackupSourceType backupSourceType;
            if (Enum.TryParse(backupSourceTypeElement.Value, out backupSourceType) == false)
            {
                return null;
            }

            bool isEnabled;
            if (bool.TryParse(enabledElement.Value, out isEnabled) == false)
            {
                return null;
            }

            bool isZipArchive;
            if (bool.TryParse(zipArchiveElement.Value, out isZipArchive) == false)
            {
                return null;
            }

            return BackupInfo.CreateBackupInfo(
                id,
                labelElement.Value,
                backupSourceType,
                isEnabled,
                isZipArchive,
                sourcePathElement.Value,
                destinationFolderPathElement.Value);
        }
    }
}