// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System.Collections.Generic;
using System.Data.Common;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Runtime.Versioning;
using System.Text;

namespace System.Data.OleDb
{
    internal struct SchemaSupport
    {
        internal Guid _schemaRowset;
        internal int _restrictions;
    }

    internal sealed class OleDbConnectionString : DbConnectionOptions
    {
        // instances of this class are intended to be immutable, i.e readonly
        // used by pooling classes so it is much easier to verify correctness
        // when not worried about the class being modified during execution

        internal static class KEY
        {
            internal const string Asynchronous_Processing = "asynchronous processing";
            internal const string Connect_Timeout = "connect timeout";
            internal const string Data_Provider = "data provider";
            internal const string Data_Source = "data source";
            internal const string Extended_Properties = "extended properties";
            internal const string File_Name = "file name";
            internal const string Initial_Catalog = "initial catalog";
            internal const string Ole_DB_Services = "ole db services";
            internal const string Persist_Security_Info = "persist security info";
            internal const string Prompt = "prompt";
            internal const string Provider = "provider";
            internal const string RemoteProvider = "remote provider";
            internal const string WindowHandle = "window handle";
        }

        // registry key and dword value entry for udl pooling
        private static class UDL
        {
            internal const string Header = "\xfeff[oledb]\r\n; Everything after this line is an OLE DB initstring\r\n";
            internal const string Location = "SOFTWARE\\Microsoft\\DataAccess\\Udl Pooling";
            internal const string Pooling = "Cache Size";

            internal static volatile bool _PoolSizeInit;
            internal static int _PoolSize;

            internal static volatile Dictionary<string, string>? _Pool;
            internal static readonly object _PoolLock = new object();
        }

        private static class VALUES
        {
            internal const string NoPrompt = "noprompt";
        }

        // set during ctor
        internal readonly bool PossiblePrompt;
        internal readonly string? ActualConnectionString; // cached value passed to GetDataSource

        private readonly string? _expandedConnectionString;

        internal SchemaSupport[]? _schemaSupport;

        internal int _sqlSupport;
        internal bool _supportMultipleResults;
        internal bool _supportIRow;
        internal bool _hasSqlSupport;
        internal bool _hasSupportMultipleResults, _hasSupportIRow;

        private int _oledbServices;

        // these are cached delegates (per unique connectionstring)
        internal UnsafeNativeMethods.IUnknownQueryInterface? DangerousDataSourceIUnknownQueryInterface;
        internal UnsafeNativeMethods.IDBInitializeInitialize? DangerousIDBInitializeInitialize;
        internal UnsafeNativeMethods.IDBCreateSessionCreateSession? DangerousIDBCreateSessionCreateSession;
        internal UnsafeNativeMethods.IDBCreateCommandCreateCommand? DangerousIDBCreateCommandCreateCommand;

        // since IDBCreateCommand interface may not be supported for a particular provider (only IOpenRowset)
        // we cache that fact rather than call QueryInterface on every call to Open
        internal bool HaveQueriedForCreateCommand;

        // SxS: if user specifies a value for "File Name=" (UDL) in connection string, OleDbConnectionString will load the connection string
        // from the UDL file. The UDL file is opened as FileMode.Open, FileAccess.Read, FileShare.Read, allowing concurrent access to it.
        internal OleDbConnectionString(string connectionString, bool validate) : base(connectionString)
        {
            string? prompt = this[KEY.Prompt];
            PossiblePrompt = ((!ADP.IsEmpty(prompt) && (!string.Equals(prompt, VALUES.NoPrompt, StringComparison.OrdinalIgnoreCase)))
                              || !ADP.IsEmpty(this[KEY.WindowHandle]));

            if (!IsEmpty)
            {
                string? udlConnectionString = null;
                if (!validate)
                {
                    int position = 0;
                    string? udlFileName = null;
                    _expandedConnectionString = ExpandDataDirectories(ref udlFileName, ref position);

                    if (!ADP.IsEmpty(udlFileName))
                    { // fail via new FileStream vs. GetFullPath
                        udlFileName = ADP.GetFullPath(udlFileName);
                    }
                    if (null != udlFileName)
                    {
                        udlConnectionString = LoadStringFromStorage(udlFileName);

                        if (!ADP.IsEmpty(udlConnectionString))
                        {
                            _expandedConnectionString = _expandedConnectionString!.Substring(0, position) + udlConnectionString + ';' + _expandedConnectionString.Substring(position);
                        }
                    }
                }
                if (validate || ADP.IsEmpty(udlConnectionString))
                {
                    ActualConnectionString = ValidateConnectionString(connectionString);
                }
            }
        }

        internal int ConnectTimeout
        {
            get { return base.ConvertValueToInt32(KEY.Connect_Timeout, ADP.DefaultConnectionTimeout); }
        }

        internal string DataSource
        {
            get { return base.ConvertValueToString(KEY.Data_Source, string.Empty)!; }
        }

        internal string InitialCatalog
        {
            get { return base.ConvertValueToString(KEY.Initial_Catalog, string.Empty)!; }
        }

        internal string Provider
        {
            get
            {
                Debug.Assert(!ADP.IsEmpty(this[KEY.Provider]), "no Provider");
                return this[KEY.Provider]!;
            }
        }

        internal int OleDbServices
        {
            get
            {
                return _oledbServices;
            }
        }

        internal SchemaSupport[]? SchemaSupport
        { // OleDbConnection.GetSchemaRowsetInformation
            get { return _schemaSupport; }
            set { _schemaSupport = value; }
        }

        protected internal override string Expand()
        {
            if (null != _expandedConnectionString)
            {
                return _expandedConnectionString;
            }
            else
            {
                return base.Expand();
            }
        }

        internal int GetSqlSupport(OleDbConnection connection)
        {
            int sqlSupport = _sqlSupport;
            if (!_hasSqlSupport)
            {
                object? value = connection.GetDataSourcePropertyValue(OleDbPropertySetGuid.DataSourceInfo, ODB.DBPROP_SQLSUPPORT);
                if (value is int)
                { // not OleDbPropertyStatus
                    sqlSupport = (int)value;
                }
                _sqlSupport = sqlSupport;
                _hasSqlSupport = true;
            }
            return sqlSupport;
        }

        internal bool GetSupportIRow(OleDbCommand command)
        {
            bool supportIRow = _supportIRow;
            if (!_hasSupportIRow)
            {
                object? value = command.GetPropertyValue(OleDbPropertySetGuid.Rowset, ODB.DBPROP_IRow);

                // SQLOLEDB always returns VARIANT_FALSE for DBPROP_IROW, so base the answer on existence
                supportIRow = !(value is OleDbPropertyStatus);
                _supportIRow = supportIRow;
                _hasSupportIRow = true;
            }
            return supportIRow;
        }

        internal bool GetSupportMultipleResults(OleDbConnection connection)
        {
            bool supportMultipleResults = _supportMultipleResults;
            if (!_hasSupportMultipleResults)
            {
                object? value = connection.GetDataSourcePropertyValue(OleDbPropertySetGuid.DataSourceInfo, ODB.DBPROP_MULTIPLERESULTS);
                if (value is int)
                {// not OleDbPropertyStatus
                    supportMultipleResults = (ODB.DBPROPVAL_MR_NOTSUPPORTED != (int)value);
                }
                _supportMultipleResults = supportMultipleResults;
                _hasSupportMultipleResults = true;
            }
            return supportMultipleResults;
        }

        private static int UdlPoolSize
        {
            // SxS: UdpPoolSize reads registry value to get the pool size
            get
            {
                int poolsize = UDL._PoolSize;
                if (!UDL._PoolSizeInit)
                {
                    object? value = ADP.LocalMachineRegistryValue(UDL.Location, UDL.Pooling);
                    if (value is int)
                    {
                        poolsize = (int)value;
                        poolsize = ((0 < poolsize) ? poolsize : 0);
                        UDL._PoolSize = poolsize;
                    }
                    UDL._PoolSizeInit = true;
                }
                return poolsize;
            }
        }

        private static string? LoadStringFromStorage(string udlfilename)
        {
            string? udlConnectionString;
            Dictionary<string, string>? udlcache = UDL._Pool;

            if ((null == udlcache) || !udlcache.TryGetValue(udlfilename, out udlConnectionString))
            {
                udlConnectionString = LoadStringFromFileStorage(udlfilename);
                if (null != udlConnectionString)
                {
                    Debug.Assert(!ADP.IsEmpty(udlfilename), "empty filename didn't fail");

                    if (0 < UdlPoolSize)
                    {
                        Debug.Assert(udlfilename == ADP.GetFullPath(udlfilename), "only cache full path filenames");

                        if (null == udlcache)
                        {
                            udlcache = new Dictionary<string, string>();
                            udlcache[udlfilename] = udlConnectionString;

                            lock (UDL._PoolLock)
                            {
                                if (null != UDL._Pool)
                                {
                                    udlcache = UDL._Pool;
                                }
                                else
                                {
                                    UDL._Pool = udlcache;
                                    udlcache = null;
                                }
                            }
                        }
                        if (null != udlcache)
                        {
                            lock (udlcache)
                            {
                                udlcache[udlfilename] = udlConnectionString;
                            }
                        }
                    }
                }
            }
            return udlConnectionString;
        }

        private static string LoadStringFromFileStorage(string udlfilename)
        {
            // Microsoft Data Link File Format
            // The first two lines of a .udl file must have exactly the following contents in order to work properly:
            //  [oledb]
            //  ; Everything after this line is an OLE DB initstring
            //
            string? connectionString = null;
            Exception? failure = null;
            try
            {
                int hdrlength = ADP.CharSize * UDL.Header.Length;
                using (FileStream fstream = new FileStream(udlfilename, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    long length = fstream.Length;
                    if (length < hdrlength || (0 != length % ADP.CharSize))
                    {
                        failure = ADP.InvalidUDL();
                    }
                    else
                    {
                        byte[] bytes = new byte[hdrlength];
                        int count = fstream.Read(bytes, 0, bytes.Length);
                        if (count < hdrlength)
                        {
                            failure = ADP.InvalidUDL();
                        }
                        else if (System.Text.Encoding.Unicode.GetString(bytes, 0, hdrlength) != UDL.Header)
                        {
                            failure = ADP.InvalidUDL();
                        }
                        else
                        { // please verify header before allocating memory block for connection string
                            bytes = new byte[length - hdrlength];
                            count = fstream.Read(bytes, 0, bytes.Length);
                            connectionString = System.Text.Encoding.Unicode.GetString(bytes, 0, count);
                        }
                    }
                }
            }
            catch (Exception e)
            {
                // UNDONE - should not be catching all exceptions!!!
                if (!ADP.IsCatchableExceptionType(e))
                {
                    throw;
                }

                throw ADP.UdlFileError(e);
            }
            if (null != failure)
            {
                throw failure;
            }
            return connectionString!.Trim();
        }

        private string ValidateConnectionString(string connectionString)
        {
            if (ConvertValueToBoolean(KEY.Asynchronous_Processing, false))
            {
                throw ODB.AsynchronousNotSupported();
            }

            int connectTimeout = ConvertValueToInt32(KEY.Connect_Timeout, 0);
            if (connectTimeout < 0)
            {
                throw ADP.InvalidConnectTimeoutValue();
            }

            string? progid = ConvertValueToString(KEY.Data_Provider, null);
            if (null != progid)
            {
                progid = progid.Trim();
                if (0 < progid.Length)
                { // don't fail on empty 'Data Provider' value
                    ValidateProvider(progid);
                }
            }
            progid = ConvertValueToString(KEY.RemoteProvider, null);
            if (null != progid)
            {
                progid = progid.Trim();
                if (0 < progid.Length)
                { // don't fail on empty 'Data Provider' value
                    ValidateProvider(progid);
                }
            }
            progid = ConvertValueToString(KEY.Provider, string.Empty)!.Trim();
            ValidateProvider(progid); // will fail on empty 'Provider' value

            // initialize to default
            // If the value is not provided in connection string and OleDbServices registry key has not been set by the provider,
            // the default for the provider is -1 (all services are ON).
            // our default is -13, we turn off ODB.DBPROPVAL_OS_AGR_AFTERSESSION and ODB.DBPROPVAL_OS_CLIENTCURSOR flags
            _oledbServices = DbConnectionStringDefaults.OleDbServices;

            bool hasOleDBServices = (base.ContainsKey(KEY.Ole_DB_Services) && !ADP.IsEmpty((string?)base[KEY.Ole_DB_Services]));
            if (!hasOleDBServices)
            { // don't touch registry if they have OLE DB Services
                string? classid = (string?)ADP.ClassesRootRegistryValue(progid + "\\CLSID", string.Empty);
                if ((null != classid) && (0 < classid.Length))
                {
                    // CLSID detection of 'Microsoft OLE DB Provider for ODBC Drivers'
                    Guid classidProvider = new Guid(classid);
                    if (ODB.CLSID_MSDASQL == classidProvider)
                    {
                        throw ODB.MSDASQLNotSupported();
                    }
                    object? tmp = ADP.ClassesRootRegistryValue("CLSID\\{" + classidProvider.ToString("D", CultureInfo.InvariantCulture) + "}", ODB.OLEDB_SERVICES);
                    if (null != tmp)
                    {
                        // @devnote: some providers like MSDataShape don't have the OLEDB_SERVICES value
                        // the MSDataShape provider doesn't support the 'Ole Db Services' keyword
                        // hence, if the value doesn't exist - don't prepend to string
                        try
                        {
                            _oledbServices = (int)tmp;
                        }
                        catch (InvalidCastException e)
                        {
                            ADP.TraceExceptionWithoutRethrow(e);
                        }
                        _oledbServices &= ~(ODB.DBPROPVAL_OS_AGR_AFTERSESSION | ODB.DBPROPVAL_OS_CLIENTCURSOR);

                        connectionString = $"{KEY.Ole_DB_Services}={_oledbServices.ToString(CultureInfo.InvariantCulture)};{connectionString}";
                    }
                }
            }
            else
            {
                // parse the Ole Db Services value from connection string
                _oledbServices = ConvertValueToInt32(KEY.Ole_DB_Services, DbConnectionStringDefaults.OleDbServices);
            }

            return connectionString;
        }

        internal static bool IsMSDASQL(string progid)
        {
            return (("msdasql" == progid) || progid.StartsWith("msdasql.", StringComparison.Ordinal) || ("microsoft ole db provider for odbc drivers" == progid));
        }

        private static void ValidateProvider(string progid)
        {
            if (ADP.IsEmpty(progid))
            {
                throw ODB.NoProviderSpecified();
            }
            if (ODB.MaxProgIdLength <= progid.Length)
            {
                throw ODB.InvalidProviderSpecified();
            }
            progid = progid.ToLowerInvariant();
            if (IsMSDASQL(progid))
            {
                // fail msdasql even if not on the machine.
                throw ODB.MSDASQLNotSupported();
            }
        }

        internal static void ReleaseObjectPool()
        {
            UDL._PoolSizeInit = false;
            UDL._Pool = null;
        }
    }
}