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


using WmData;


namespace FreeNameLibrary {
    public class WmDataIntermediar {

        protected static WmData.WmDirectData data;
        protected static WmData.WmDirectData Data {
            get { return data; }
            set { data = value; }
        }
        public static void initiateData(string databaseUsername, string databasePassword, string databaseHost, int databasePort, string databaseCatalog) {
            data = new WmData.WmDirectData(databaseUsername, databasePassword, databaseHost, databasePort, databaseCatalog);
            RegisterInterface.initRegisterInterface();
        }

        #region NameCheck, NameCheckResult
        public static NameCheck performNameCheck(string name) {
            NameCheck nameCheck = new NameCheck();
            nameCheck.Name = name;
            nameCheck.Created = DateTime.Now;
            
            nameCheck.DomainName = Tools.purify(name).ToLower();

            WmDataIntermediar.addNameCheck(nameCheck);

            List<NameCheckResult> nameCheckResults = new List<NameCheckResult>();

            if (getDomainType(nameCheck.Name) == DomainType.UNSUPPORTED) {
                string domainNamePrefix = nameCheck.DomainName;

                List<string> commonTlds = new List<string>();
                commonTlds.Add(".com");
                commonTlds.Add(".net");
                commonTlds.Add(".org");
                commonTlds.Add(".eu");
                commonTlds.Add(".nl");
                commonTlds.Add(".fr");
                commonTlds.Add(".de");
                commonTlds.Add(".co.uk");
                //     commonTlds.Add(".fr");
                //     commonTlds.Add(".it");
                commonTlds.Add(".es");

                // the domain name prefix is not a fully specified domainn name, perform common TLD checks:
                foreach (string commonTld in commonTlds) {
                    string domainNameToCheck = domainNamePrefix + commonTld;

                    NameCheckResult domainCheckResult = new NameCheckResult();
                    domainCheckResult.NameCheckId = nameCheck.Id;
                    domainCheckResult.TestValue = domainNameToCheck;
                    domainCheckResult.Created = DateTime.Now;
                    domainCheckResult.NameCheckType = NameCheckType.INTERNET_DOMAIN_NAME;
                    domainCheckResult.IsAvailable = (getDomainCheckResult(domainNameToCheck) == DomainCheckResult.CAN_BE_REGISTERED);
                    WmDataIntermediar.addNameCheckResult(domainCheckResult);
                    nameCheckResults.Add(domainCheckResult);
                }
            } else { // the entered name is a domain name in itself, simply execute that name
                NameCheckResult domainCheckResult = new NameCheckResult();
                domainCheckResult.NameCheckId = nameCheck.Id;
                domainCheckResult.TestValue = nameCheck.Name.Replace(" ","").Replace("'","");
                domainCheckResult.Created = DateTime.Now;
                domainCheckResult.NameCheckType = NameCheckType.INTERNET_DOMAIN_NAME;
                domainCheckResult.IsAvailable = (getDomainCheckResult(nameCheck.DomainName) == DomainCheckResult.CAN_BE_REGISTERED);
                WmDataIntermediar.addNameCheckResult(domainCheckResult);
                nameCheckResults.Add(domainCheckResult);
                nameCheck.DomainName = domainCheckResult.TestValue;
                WmDataIntermediar.updateNameCheck(nameCheck);
            }


            NameCheckResult twitterResult = new NameCheckResult();
            twitterResult.NameCheckId = nameCheck.Id;
            twitterResult.TestValue = TwitterInterface.optimizeNameForTwitter(nameCheck.Name) ;
            twitterResult.Created = DateTime.Now;
            twitterResult.NameCheckType = NameCheckType.TWITTER;
            twitterResult.IsAvailable = TwitterInterface.isUsernameAvailable(twitterResult.TestValue);
            WmDataIntermediar.addNameCheckResult(twitterResult);
            nameCheckResults.Add(twitterResult);

            NameCheckResult iTunesResult = new NameCheckResult();
            iTunesResult.NameCheckId = nameCheck.Id;
            iTunesResult.TestValue = nameCheck.Name;
            iTunesResult.Created = DateTime.Now;
            iTunesResult.NameCheckType = NameCheckType.APPLE_ITUNES;
            iTunesResult.IsAvailable = GoogleInterface.isNameUnknownAtItunes(iTunesResult.TestValue);
            WmDataIntermediar.addNameCheckResult(iTunesResult);
            nameCheckResults.Add(iTunesResult);

            NameCheckResult googleResult = new NameCheckResult();
            googleResult.NameCheckId = nameCheck.Id;
            googleResult.TestValue = nameCheck.Name;
            googleResult.Created = DateTime.Now;
            googleResult.NameCheckType = NameCheckType.INTERNET_SEARCH;
            googleResult.IsAvailable = GoogleInterface.isNameUnknownByGoogle(googleResult.TestValue);
            WmDataIntermediar.addNameCheckResult(googleResult);
            nameCheckResults.Add(googleResult);

            bool isAvailableOverall = true;
            foreach (NameCheckResult result in nameCheckResults) {
                if (!result.IsAvailable) {
                    isAvailableOverall = false;
                    break;
                }
            }
            nameCheck.IsAvailable = isAvailableOverall;


            return nameCheck;
        }


        public static void addNameCheckResult(NameCheckResult addItem) {
            Data.addObject(addItem);
        }
        public static void updateNameCheckResult(NameCheckResult updateItem) {
            Data.updateObject(updateItem);
        }
        public static void deleteNameCheckResult(NameCheckResult deleteItem) {
            Data.deleteObject(deleteItem);
        }
        public static NameCheckResult[] getNameCheckResults(string select) {
            ArrayList tmpRes = Data.getObjects(typeof(NameCheckResult), select);
            return (NameCheckResult[])tmpRes.ToArray(typeof(NameCheckResult));
        }

        public static void addNameCheck(NameCheck addItem) {
            Data.addObject(addItem);
        }
        public static void updateNameCheck(NameCheck updateItem) {
            Data.updateObject(updateItem);
        }
        public static void deleteNameCheck(NameCheck deleteItem) {
            Data.deleteObject(deleteItem);
        }

        #endregion

        #region CachedDomainCheckResult and DomainCheck

        public static void addCachedDomainCheckResult(CachedDomainCheckResult addItem) {
            Data.addObject(addItem);
        }
        public static void updateCachedDomainCheckResult(CachedDomainCheckResult updateItem) {
            Data.updateObject(updateItem);
        }
        public static void deleteCachedDomainCheckResult(CachedDomainCheckResult deleteItem) {
            Data.deleteObject(deleteItem);
        }

        public static CachedDomainCheckResult getCachedDomainCheckResult(string select) {
            return (CachedDomainCheckResult)Data.getObject(typeof(CachedDomainCheckResult), select);
        }
        public static CachedDomainCheckResult getCachedDomainCheckResult(int id) {
            return (CachedDomainCheckResult)Data.getObject(typeof(CachedDomainCheckResult), id);
        }
        public static CachedDomainCheckResult[] getCachedDomainCheckResults(string select) {
            ArrayList tmpRes = Data.getObjects(typeof(CachedDomainCheckResult), select);
            return (CachedDomainCheckResult[])tmpRes.ToArray(typeof(CachedDomainCheckResult));
        }
        public static bool isDomainNameTransfer(string domainName) {
            bool isTransfer = true;
            if (RegisterInterface.checkDomain(domainName) == DomainCheckResult.CAN_BE_REGISTERED) {
                isTransfer = false;
            }
            return isTransfer;
        }
       

        public static DomainCheckResult getDomainCheckResult(string domainName) {
            DomainCheckResult returnResult = DomainCheckResult.CANNOT_BE_REQUESTED;

            // This is a pre check to filter out domains we do not register in all situations
            DomainType domainType = getDomainType(domainName);
            if (domainType == DomainType.UNSUPPORTED) {
                returnResult = DomainCheckResult.CANNOT_BE_REQUESTED;
            } else {
                // Else we're go for a 'real' check using our cache
                string select = "domainname='" + domainName + "'";

                CachedDomainCheckResult cachedResult = getCachedDomainCheckResult(select);
                if (cachedResult == null) { // the domain is not cached, make a 'real real real' request than:
                    cachedResult = new CachedDomainCheckResult();
                    cachedResult.DomainCheckResult = DomainCheckResult.CANNOT_BE_REQUESTED;
                    cachedResult.Created = DateTime.Now;
                    cachedResult.DomainName = domainName;

                    // Use the RegisterInterface to request the domainname status:
                    DomainCheckResult checkResult = RegisterInterface.checkDomain(domainName);
                    cachedResult.DomainCheckResult = checkResult;
                    addCachedDomainCheckResult(cachedResult);

                    returnResult = cachedResult.DomainCheckResult;
                } else {
                    if (cachedResult.Created.AddDays(10) < DateTime.Now) {
                        deleteCachedDomainCheckResult(cachedResult);
                        returnResult = getDomainCheckResult(domainName);
                    } else {
                        returnResult = cachedResult.DomainCheckResult;
                    }
                }
                
            }
           

            return returnResult;
        }
        public static void addDomainCheck(DomainCheck domainCheck) {
            Data.addObject(domainCheck);
        }
        public static void updateDomainCheck(DomainCheck domainCheck) {
            Data.updateObject(domainCheck);
        }
        public static DomainCheck getDomainCheck(string select) {
            return (DomainCheck)Data.getObject(typeof(DomainCheck), select);
        }
        public static DomainCheck[] getDomainChecks(string select) {
            ArrayList tmpRes = Data.getObjects(typeof(DomainCheck), select);
            tmpRes.Sort();
            tmpRes.Reverse(); // most recent checks on top
            return (DomainCheck[])tmpRes.ToArray(typeof(DomainCheck));
        }

        public static DomainCheck[] getRecentUniqueDomainChecks() {
            ArrayList tmpRes = new ArrayList();

            DomainCheck[] checks = getDomainChecks(null);
            int i = 0;
            while (tmpRes.Count < 14) {
                DomainCheck possibleCheck = checks[i];

                bool isNew = true;
                foreach (DomainCheck check in tmpRes) {
                    string firstPartOfDomainNameCheck = check.DomainName.Split('.')[0];
                    string firstPartOfDomainNamePossible = possibleCheck.DomainName.Split('.')[0];
                    if (firstPartOfDomainNameCheck.Equals(firstPartOfDomainNamePossible)) {
                        isNew = false;
                        break;
                    }
                }

                if (isNew) {
                    tmpRes.Add(possibleCheck);
                }

                i++;
            }


            return (DomainCheck[])tmpRes.ToArray(typeof(DomainCheck));
        }

       

        #endregion

        #region CachedDomainWhoisResult and WHOIS
        public static CachedDomainWhoisResult getCachedDomainWhoisResult(int id) {
            return (CachedDomainWhoisResult)Data.getObject(typeof(CachedDomainWhoisResult), id);
        }
        public static CachedDomainWhoisResult getCachedDomainWhoisResult(string select) {
            return (CachedDomainWhoisResult)Data.getObject(typeof(CachedDomainWhoisResult), select);
        }
        public static CachedDomainWhoisResult[] getCachedDomainWhoisResults(string select) {
            ArrayList tmpRes = Data.getObjects(typeof(CachedDomainWhoisResult), select);
            return (CachedDomainWhoisResult[])tmpRes.ToArray(typeof(CachedDomainWhoisResult));
        }
        public static void addCachedDomainWhoisResult(CachedDomainWhoisResult result) {
            Data.addObject(result);
        }
        public static void updateCachedDomainWhoisResult(CachedDomainWhoisResult result) {
            Data.updateObject(result);
        }
        public static void deleteCachedDomainWhoisResult(CachedDomainWhoisResult result) {
            Data.deleteObject(result);
        }

        public static string getWhoisDataForDomain(string domainName) {
            string cacheSelect = "domainname='" + domainName + "'";
            CachedDomainWhoisResult cacheResult = getCachedDomainWhoisResult(cacheSelect);
            if (cacheResult != null) {
                return cacheResult.Data;
            } else {
                string cacheData = RegisterInterface.getWhoisDataForDomainName(domainName);
                cacheResult = new CachedDomainWhoisResult();
                cacheResult.Data = cacheData;
                cacheResult.Created = DateTime.Now;
                cacheResult.DomainName = domainName;
                addCachedDomainWhoisResult(cacheResult);
                return cacheData;
            }
        }



        #endregion

        /// <summary>
        /// Returns the domain type that is used to determine if the domainname is supported for 
        /// registration and what kind of registration is required.
        /// </summary>
        /// <param name="domainName"></param>
        /// <returns></returns>
        public static DomainType getDomainType(string domainName) {
            if (domainName.EndsWith(".com") ||
                domainName.EndsWith(".net") ||
                domainName.EndsWith(".org") ||
                domainName.EndsWith(".info") ||
                domainName.EndsWith(".eu") ||
                domainName.EndsWith(".nl") ||
                domainName.EndsWith(".be") ||
                domainName.EndsWith(".us") ||
                domainName.EndsWith(".biz")) {
                return DomainType.NORMAL;
            } else if (domainName.EndsWith(".name") ||
                domainName.EndsWith(".me") ||
                domainName.EndsWith(".mobi") ||
                domainName.EndsWith(".ws") ||
                domainName.EndsWith(".de") ||
                domainName.EndsWith(".fr") ||
                domainName.EndsWith(".nu") ||
                domainName.EndsWith(".es") ||
                domainName.EndsWith(".co.uk") ||
                domainName.EndsWith(".tv")) {
                return DomainType.EXOTIC;
            } else {
                return DomainType.UNSUPPORTED;
            }
        }

    }

    /// <summary>
    /// Returns the classification of a domainname that is used
    /// to determine the required domainname registration contract
    /// </summary>
    public enum DomainType {
        /// <summary>
        /// .com, .net, .org, .info, .eu, .nl, .be, .us, .biz
        /// </summary>
        NORMAL = 0,

        /// <summary>
        /// Everything else that is suppored
        /// </summary>
        EXOTIC = 1,

        /// <summary>
        /// We do not support this tld
        /// </summary>
        UNSUPPORTED = -1
    }
}