using Ryujinx.Common.Logging;
using Ryujinx.HLE.Exceptions;
using Ryujinx.HLE.HOS.Ipc;
using Ryujinx.HLE.HOS.Kernel.Common;
using Ryujinx.HLE.HOS.Kernel.Threading;
using Ryujinx.HLE.HOS.Services.Hid;
using System;
using System.Collections.Generic;

namespace Ryujinx.HLE.HOS.Services.Nfc.Nfp
{
    class IUser : IpcService
    {
        private State _state = State.NonInitialized;

        private KEvent _availabilityChangeEvent;
        private int    _availabilityChangeEventHandle = 0;

        private List<Device> _devices = new List<Device>();

        private Dictionary<int, ServiceProcessRequest> _commands;

        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => _commands;

        public IUser()
        {
            _commands = new Dictionary<int, ServiceProcessRequest>
            {
                { 0,  Initialize                    },
                { 1,  Finalize                      },
                { 2,  ListDevices                   },
                { 3,  StartDetection                },
                { 4,  StopDetection                 },
                { 5,  Mount                         },
                { 6,  Unmount                       },
                { 7,  OpenApplicationArea           },
                { 8,  GetApplicationArea            },
                { 9,  SetApplicationArea            },
                { 10, Flush                         },
                { 11, Restore                       },
                { 12, CreateApplicationArea         },
                { 13, GetTagInfo                    },
                { 14, GetRegisterInfo               },
                { 15, GetCommonInfo                 },
                { 16, GetModelInfo                  },
                { 17, AttachActivateEvent           },
                { 18, AttachDeactivateEvent         },
                { 19, GetState                      },
                { 20, GetDeviceState                },
                { 21, GetNpadId                     },
                { 22, GetApplicationAreaSize        },
                { 23, AttachAvailabilityChangeEvent }, // 3.0.0+
                { 24, RecreateApplicationArea       }, // 3.0.0+
            };
        }

        // Initialize(u64, u64, pid, buffer<unknown, 5>)
        public long Initialize(ServiceCtx context)
        {
            long appletResourceUserId = context.RequestData.ReadInt64();
            long mcuVersionData       = context.RequestData.ReadInt64();

            long inputPosition = context.Request.SendBuff[0].Position;
            long inputSize     = context.Request.SendBuff[0].Size;

            byte[] unknownBuffer = context.Memory.ReadBytes(inputPosition, inputSize);

            // NOTE: appletResourceUserId, mcuVersionData and the buffer are stored inside an internal struct.
            //       The buffer seems to contains entries with a size of 0x40 bytes each.
            //       Sadly, this internal struct doesn't seems to be used in retail.

            // TODO: Add an instance of nn::nfc::server::Manager when it will be implemented.
            //       Add an instance of nn::nfc::server::SaveData when it will be implemented.

            // TODO: When we will be able to add multiple controllers add one entry by controller here.
            Device device1 = new Device
            {
                NpadIdType = NpadIdType.Player1,
                Handle     = HidUtils.GetIndexFromNpadIdType(NpadIdType.Player1),
                State      = DeviceState.Initialized
            };

            _devices.Add(device1);

            _state = State.Initialized;

            return 0;
        }

        // Finalize()
        public long Finalize(ServiceCtx context)
        {
            // TODO: Call StopDetection() and Unmount() when they will be implemented.
            //       Remove the instance of nn::nfc::server::Manager when it will be implemented.
            //       Remove the instance of nn::nfc::server::SaveData when it will be implemented.

            _devices.Clear();

            _state = State.NonInitialized;

            return 0;
        }

        // ListDevices() -> (u32, buffer<unknown, 0xa>)
        public long ListDevices(ServiceCtx context)
        {
            if (context.Request.RecvListBuff.Count == 0)
            {
                return ErrorCode.MakeError(ErrorModule.Nfp, NfpError.DevicesBufferIsNull);
            }

            long outputPosition = context.Request.RecvListBuff[0].Position;
            long outputSize     = context.Request.RecvListBuff[0].Size;

            if (_devices.Count == 0)
            {
                return ErrorCode.MakeError(ErrorModule.Nfp, NfpError.DeviceNotFound);
            }

            for (int i = 0; i < _devices.Count; i++)
            {
                context.Memory.WriteUInt32(outputPosition + (i * sizeof(long)), (uint)_devices[i].Handle);
            }

            context.ResponseData.Write(_devices.Count);

            return 0;
        }

        // StartDetection(bytes<8, 4>)
        public long StartDetection(ServiceCtx context)
        {
            throw new ServiceNotImplementedException(context);
        }

        // StopDetection(bytes<8, 4>)
        public long StopDetection(ServiceCtx context)
        {
            throw new ServiceNotImplementedException(context);
        }

        // Mount(bytes<8, 4>, u32, u32)
        public long Mount(ServiceCtx context)
        {
            throw new ServiceNotImplementedException(context);
        }

        // Unmount(bytes<8, 4>)
        public long Unmount(ServiceCtx context)
        {
            throw new ServiceNotImplementedException(context);
        }

        // OpenApplicationArea(bytes<8, 4>, u32)
        public long OpenApplicationArea(ServiceCtx context)
        {
            throw new ServiceNotImplementedException(context);
        }

        // GetApplicationArea(bytes<8, 4>) -> (u32, buffer<unknown, 6>)
        public long GetApplicationArea(ServiceCtx context)
        {
            throw new ServiceNotImplementedException(context);
        }

        // SetApplicationArea(bytes<8, 4>, buffer<unknown, 5>)
        public long SetApplicationArea(ServiceCtx context)
        {
            throw new ServiceNotImplementedException(context);
        }

        // Flush(bytes<8, 4>)
        public long Flush(ServiceCtx context)
        {
            throw new ServiceNotImplementedException(context);
        }

        // Restore(bytes<8, 4>)
        public long Restore(ServiceCtx context)
        {
            throw new ServiceNotImplementedException(context);
        }

        // CreateApplicationArea(bytes<8, 4>, u32, buffer<unknown, 5>)
        public long CreateApplicationArea(ServiceCtx context)
        {
            throw new ServiceNotImplementedException(context);
        }

        // GetTagInfo(bytes<8, 4>) -> buffer<unknown<0x58>, 0x1a>
        public long GetTagInfo(ServiceCtx context)
        {
            throw new ServiceNotImplementedException(context);
        }

        // GetRegisterInfo(bytes<8, 4>) -> buffer<unknown<0x100>, 0x1a>
        public long GetRegisterInfo(ServiceCtx context)
        {
            throw new ServiceNotImplementedException(context);
        }

        // GetCommonInfo(bytes<8, 4>) -> buffer<unknown<0x40>, 0x1a>
        public long GetCommonInfo(ServiceCtx context)
        {
            throw new ServiceNotImplementedException(context);
        }

        // GetModelInfo(bytes<8, 4>) -> buffer<unknown<0x40>, 0x1a>
        public long GetModelInfo(ServiceCtx context)
        {
            throw new ServiceNotImplementedException(context);
        }

        // AttachActivateEvent(bytes<8, 4>) -> handle<copy>
        public long AttachActivateEvent(ServiceCtx context)
        {
            uint deviceHandle = context.RequestData.ReadUInt32();

            for (int i = 0; i < _devices.Count; i++)
            {
                if ((uint)_devices[i].Handle == deviceHandle)
                {
                    if (_devices[i].ActivateEventHandle == 0)
                    {
                        _devices[i].ActivateEvent = new KEvent(context.Device.System);

                        if (context.Process.HandleTable.GenerateHandle(_devices[i].ActivateEvent.ReadableEvent, out _devices[i].ActivateEventHandle) != KernelResult.Success)
                        {
                            throw new InvalidOperationException("Out of handles!");
                        }
                    }

                    context.Response.HandleDesc = IpcHandleDesc.MakeCopy(_devices[i].ActivateEventHandle);

                    return 0;
                }
            }

            return ErrorCode.MakeError(ErrorModule.Nfp, NfpError.DeviceNotFound);
        }

        // AttachDeactivateEvent(bytes<8, 4>) -> handle<copy>
        public long AttachDeactivateEvent(ServiceCtx context)
        {
            uint deviceHandle = context.RequestData.ReadUInt32();

            for (int i = 0; i < _devices.Count; i++)
            {
                if ((uint)_devices[i].Handle == deviceHandle)
                {
                    if (_devices[i].DeactivateEventHandle == 0)
                    {
                        _devices[i].DeactivateEvent = new KEvent(context.Device.System);

                        if (context.Process.HandleTable.GenerateHandle(_devices[i].DeactivateEvent.ReadableEvent, out _devices[i].DeactivateEventHandle) != KernelResult.Success)
                        {
                            throw new InvalidOperationException("Out of handles!");
                        }
                    }

                    context.Response.HandleDesc = IpcHandleDesc.MakeCopy(_devices[i].DeactivateEventHandle);

                    return 0;
                }
            }

            return ErrorCode.MakeError(ErrorModule.Nfp, NfpError.DeviceNotFound);
        }

        // GetState() -> u32
        public long GetState(ServiceCtx context)
        {
            context.ResponseData.Write((int)_state);

            return 0;
        }

        // GetDeviceState(bytes<8, 4>) -> u32
        public long GetDeviceState(ServiceCtx context)
        {
            uint deviceHandle = context.RequestData.ReadUInt32();

            for (int i = 0; i < _devices.Count; i++)
            {
                if ((uint)_devices[i].Handle == deviceHandle)
                {
                    context.ResponseData.Write((uint)_devices[i].State);

                    return 0;
                }
            }

            context.ResponseData.Write((uint)DeviceState.Unavailable);

            return ErrorCode.MakeError(ErrorModule.Nfp, NfpError.DeviceNotFound);
        }

        // GetNpadId(bytes<8, 4>) -> u32
        public long GetNpadId(ServiceCtx context)
        {
            uint deviceHandle = context.RequestData.ReadUInt32();

            for (int i = 0; i < _devices.Count; i++)
            {
                if ((uint)_devices[i].Handle == deviceHandle)
                {
                    context.ResponseData.Write((uint)HidUtils.GetNpadIdTypeFromIndex(_devices[i].Handle));

                    return 0;
                }
            }

            return ErrorCode.MakeError(ErrorModule.Nfp, NfpError.DeviceNotFound);
        }

        // GetApplicationAreaSize(bytes<8, 4>) -> u32
        public long GetApplicationAreaSize(ServiceCtx context)
        {
            throw new ServiceNotImplementedException(context);
        }

        // AttachAvailabilityChangeEvent() -> handle<copy>
        public long AttachAvailabilityChangeEvent(ServiceCtx context)
        {
            if (_availabilityChangeEventHandle == 0)
            {
                _availabilityChangeEvent = new KEvent(context.Device.System);

                if (context.Process.HandleTable.GenerateHandle(_availabilityChangeEvent.ReadableEvent, out _availabilityChangeEventHandle) != KernelResult.Success)
                {
                    throw new InvalidOperationException("Out of handles!");
                }
            }

            context.Response.HandleDesc = IpcHandleDesc.MakeCopy(_availabilityChangeEventHandle);

            return 0;
        }

        // RecreateApplicationArea(bytes<8, 4>, u32, buffer<unknown, 5>)
        public long RecreateApplicationArea(ServiceCtx context)
        {
            throw new ServiceNotImplementedException(context);
        }
    }
}