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

using System;
using Microsoft.Build.BackEnd;

namespace Microsoft.Build.Experimental.FileAccess
{
    /// <summary>
    /// File access data.
    /// </summary>
    [CLSCompliant(false)]
    public struct FileAccessData
        : ITranslatable
    {
        private ReportedFileOperation _operation;
        private RequestedAccess _requestedAccess;
        private uint _processId;
        private uint _id;
        private uint _correlationId;
        private uint _error;
        private DesiredAccess _desiredAccess;
        private FlagsAndAttributes _flagsAndAttributes;
        private string _path;
        private string? _processArgs;
        private bool _isAnAugmentedFileAccess;
        private string? _enumeratePattern;
        private FlagsAndAttributes _openedFileOrDirectoryAttributes;

        public FileAccessData(
            ReportedFileOperation operation,
            RequestedAccess requestedAccess,
            uint processId,
            uint id,
            uint correlationId,
            uint error,
            DesiredAccess desiredAccess,
            FlagsAndAttributes flagsAndAttributes,
            string path,
            string? processArgs,
            bool isAnAugmentedFileAccess)
            // This overload predates EnumeratePattern and OpenedFileOrDirectoryAttributes; callers using it have
            // no values to supply, so they default to "not provided": no enumeration pattern and no attributes.
            : this(
                operation,
                requestedAccess,
                processId,
                id,
                correlationId,
                error,
                desiredAccess,
                flagsAndAttributes,
                path,
                processArgs,
                isAnAugmentedFileAccess,
                enumeratePattern: null,
                openedFileOrDirectoryAttributes: 0)
        {
        }

        public FileAccessData(
            ReportedFileOperation operation,
            RequestedAccess requestedAccess,
            uint processId,
            uint id,
            uint correlationId,
            uint error,
            DesiredAccess desiredAccess,
            FlagsAndAttributes flagsAndAttributes,
            string path,
            string? processArgs,
            bool isAnAugmentedFileAccess,
            string? enumeratePattern,
            FlagsAndAttributes openedFileOrDirectoryAttributes)
        {
            _operation = operation;
            _requestedAccess = requestedAccess;
            _processId = processId;
            _id = id;
            _correlationId = correlationId;
            _error = error;
            _desiredAccess = desiredAccess;
            _flagsAndAttributes = flagsAndAttributes;
            _path = path;
            _processArgs = processArgs;
            _isAnAugmentedFileAccess = isAnAugmentedFileAccess;
            _enumeratePattern = enumeratePattern;
            _openedFileOrDirectoryAttributes = openedFileOrDirectoryAttributes;
        }

        /// <summary>The operation that performed the file access.</summary>
        public ReportedFileOperation Operation
        {
            readonly get => _operation;
            private set => _operation = value;
        }

        /// <summary>The requested access.</summary>
        public RequestedAccess RequestedAccess
        {
            readonly get => _requestedAccess;
            private set => _requestedAccess = value;
        }

        /// <summary>The process id.</summary>
        public uint ProcessId
        {
            readonly get => _processId;
            private set => _processId = value;
        }

        /// <summary>Id of file access.</summary>
        public uint Id
        {
            readonly get => _id;
            private set => _id = value;
        }


        /// <summary>Correlation id of file access.</summary>
        public uint CorrelationId
        {
            readonly get => _correlationId;
            private set => _correlationId = value;
        }


        /// <summary>The error code of the operation.</summary>
        public uint Error
        {
            readonly get => _error;
            private set => _error = value;
        }

        /// <summary>The desired access.</summary>
        public DesiredAccess DesiredAccess
        {
            readonly get => _desiredAccess;
            private set => _desiredAccess = value;
        }

        /// <summary>The file flags and attributes.</summary>
        public FlagsAndAttributes FlagsAndAttributes
        {
            readonly get => _flagsAndAttributes;
            private set => _flagsAndAttributes = value;
        }

        /// <summary>The path being accessed.</summary>
        public string Path
        {
            readonly get => _path;
            private set => _path = value;
        }

        /// <summary>The process arguments.</summary>
        public string? ProcessArgs
        {
            readonly get => _processArgs;
            private set => _processArgs = value;
        }

        /// <summary>Whether the file access is augmented.</summary>
        public bool IsAnAugmentedFileAccess
        {
            readonly get => _isAnAugmentedFileAccess;
            private set => _isAnAugmentedFileAccess = value;
        }

        /// <summary>
        /// The search pattern passed to a directory enumeration API (e.g., the <c>lpFileName</c>
        /// pattern argument to <c>FindFirstFileEx</c> such as <c>*.cs</c>). <see langword="null"/>
        /// for accesses that are not directory enumerations.
        /// </summary>
        public string? EnumeratePattern
        {
            readonly get => _enumeratePattern;
            private set => _enumeratePattern = value;
        }

        /// <summary>
        /// The actual flags and attributes of the opened file or directory as resolved by the
        /// kernel. Contrast with <see cref="FlagsAndAttributes"/>, which reflects what the caller
        /// requested when opening the handle.
        /// </summary>
        public FlagsAndAttributes OpenedFileOrDirectoryAttributes
        {
            readonly get => _openedFileOrDirectoryAttributes;
            private set => _openedFileOrDirectoryAttributes = value;
        }

        void ITranslatable.Translate(ITranslator translator)
        {
            translator.TranslateEnum(ref _operation, (int)_operation);
            translator.TranslateEnum(ref _requestedAccess, (int)_requestedAccess);
            translator.Translate(ref _processId);
            translator.Translate(ref _id);
            translator.Translate(ref _correlationId);
            translator.Translate(ref _error);
            translator.TranslateEnum(ref _desiredAccess, (int)_desiredAccess);
            translator.TranslateEnum(ref _flagsAndAttributes, (int)_flagsAndAttributes);
            translator.Translate(ref _path);
            translator.Translate(ref _processArgs);
            translator.Translate(ref _isAnAugmentedFileAccess);
            translator.Translate(ref _enumeratePattern);
            translator.TranslateEnum(ref _openedFileOrDirectoryAttributes, (int)_openedFileOrDirectoryAttributes);
        }
    }
}