using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Chtn.CSharp.SDK.Core;
using Chtn.CSharp.SDK.Models.Network;

namespace Chtn.CSharp.SDK.Services
{
    public interface INetworkService
    {
        // General & Discovery
        Task<NetworkInvite> CreateInvite(CreateInviteReq req);
        Task<List<NetworkInvite>> GetInvites();
        Task Create(CreateNetworkReq req);
        Task<List<Network>> GetNetworks();
        Task AcceptInvite(AcceptInviteReq req);
        Task JoinPublicNetwork(JoinPublicNetworkReq req);
        Task Leave();
        Task Delete();
        Task<Network> GetFromInvite(string inviteCode);
        Task<NetworkDiscovery> GetDiscovery();

        // Categories
        Task CreateCategory(CreateCategoryReq req);
        Task DeleteCategory(string categoryId);
        Task MoveCategory(MoveCategoryReq req);
        Task EditCategory(EditCategoryReq req);
        Task ToggleCategoryMute(ToggleCategoryMuteReq req);

        // Channels
        Task CreateChannel(CreateChannelReq req);
        Task EditChannel(EditChannelReq req);
        Task ToggleChannelMute(ToggleChannelMuteReq req);

        // Ranks & Members
        Task CreateRank(CreateRankReq req);
        Task DeleteRank(DeleteRankReq req);
        Task MoveRank(MoveRankReq req);
        Task EditRank(EditRankReq req);
        Task AssignRankToMember(AssignRankToMemberReq req);
        Task RemoveRankFromMember(RemoveRankFromMemberReq req);
        Task<List<NetworkMember>> GetMembers(GetMembersReq req);

        // Moderation
        Task KickMember(KickMemberReq req);
        Task BanMember(BanMemberReq req);
        Task UnbanMember(UnbanMemberReq req);
        Task<List<BannedMember>> GetBannedMembers(GetBannedMembersReq req);

        // Permissions & Overwrites
        Task ModifyRankPermissions(ModifyPermissionsReq req);
        Task OverwritePermission(OverwritePermissionReq req);
        Task OverwriteChannelPermission(OverwriteChannelPermissionReq req);
        Task<List<PermissionOverwrite>> GetOverwrites(GetOverwritesReq req);
        Task<List<PermissionOverwrite>> GetChannelOverwrites(GetChannelOverwritesReq req);

        // Settings & Real-time
        Task UploadNewPic(UploadNewPictureReq req);
        Task ChangeVisibility(ChangeVisibilityReq req);
        Task EditName(EditNameReq req);
        Task ToggleMute(ToggleNetworkMuteReq req);
        Task JoinWebSocketRoom(JoinWebSocketRoomReq req);
    }

    public class NetworkService : INetworkService
    {
        private readonly ApiClient _apiClient;
        private readonly string _userId;
        private readonly string _token;
        private readonly string _networkId;
        private readonly string _database;

        public NetworkService(ApiClient apiClient, string userId, string token, string networkId, string database)
        {
            _apiClient = apiClient ?? throw new ArgumentNullException(nameof(apiClient));
            _userId = userId ?? throw new ArgumentNullException(nameof(userId));
            _token = token ?? throw new ArgumentNullException(nameof(token));
            _networkId = networkId ?? throw new ArgumentNullException(nameof(networkId));
            _database = database ?? throw new ArgumentNullException(nameof(database));
        }

        #region General & Discovery
        public async Task<NetworkInvite> CreateInvite(CreateInviteReq req) =>
            await _apiClient.PostAsync<CreateInviteReq, NetworkInvite>("network/createInvite", req);

        public async Task<List<NetworkInvite>> GetInvites() =>
            await _apiClient.GetAsync<List<NetworkInvite>>($"network/invites?networkId={_networkId}");

        public async Task Create(CreateNetworkReq req) =>
            await _apiClient.PostAsync<CreateNetworkReq, object>("network/create", req);

        public async Task<List<Network>> GetNetworks() =>
            await _apiClient.GetAsync<List<Network>>("network/get");

        public async Task AcceptInvite(AcceptInviteReq req) =>
            await _apiClient.PostAsync<AcceptInviteReq, object>("network/acceptInvite", req);

        public async Task JoinPublicNetwork(JoinPublicNetworkReq req) =>
            await _apiClient.PostAsync<JoinPublicNetworkReq, object>("network/joinNetworkDiscovery", req);

        public async Task Leave() =>
            await _apiClient.DeleteAsync<object>($"network/leave/{_networkId}/{_userId}");

        public async Task Delete() =>
            await _apiClient.DeleteAsync<object>($"network/delete/{_networkId}");

        public async Task<Network> GetFromInvite(string inviteCode) =>
            await _apiClient.GetAsync<Network>($"network/fromInvite?code={inviteCode}");

        public async Task<NetworkDiscovery> GetDiscovery() =>
            await _apiClient.GetAsync<NetworkDiscovery>("network/discovery");
        #endregion

        #region Categories
        public async Task CreateCategory(CreateCategoryReq req) =>
            await _apiClient.PostAsync<CreateCategoryReq, object>("network/createCategory", req);

        public async Task DeleteCategory(string categoryId) =>
            await _apiClient.DeleteAsync<object>($"network/deleteCategory/{_networkId}/{categoryId}");

        public async Task MoveCategory(MoveCategoryReq req) =>
            await _apiClient.PatchAsync<MoveCategoryReq, object>("network/moveCategory", req);

        public async Task EditCategory(EditCategoryReq req) =>
            await _apiClient.PatchAsync<EditCategoryReq, object>("network/editCategory", req);

        public async Task ToggleCategoryMute(ToggleCategoryMuteReq req) =>
            await _apiClient.PostAsync<ToggleCategoryMuteReq, object>("network/toggleCatMute", req);
        #endregion

        #region Channels
        public async Task CreateChannel(CreateChannelReq req) =>
            await _apiClient.PostAsync<CreateChannelReq, object>("network/createChannel", req);

        public async Task EditChannel(EditChannelReq req) =>
            await _apiClient.PatchAsync<EditChannelReq, object>("network/editChannel", req);

        public async Task ToggleChannelMute(ToggleChannelMuteReq req) =>
            await _apiClient.PostAsync<ToggleChannelMuteReq, object>("network/toggleChanMute", req);
        #endregion

        #region Ranks & Members
        public async Task CreateRank(CreateRankReq req) =>
            await _apiClient.PostAsync<CreateRankReq, object>("network/createRank", req);

        public async Task DeleteRank(DeleteRankReq req) =>
            await _apiClient.DeleteAsync<object>($"network/deleteRank/{_networkId}/{req.RankId}");

        public async Task MoveRank(MoveRankReq req) =>
            await _apiClient.PatchAsync<MoveRankReq, object>("network/moveRank", req);

        public async Task EditRank(EditRankReq req) =>
            await _apiClient.PatchAsync<EditRankReq, object>("network/editRank", req);

        public async Task AssignRankToMember(AssignRankToMemberReq req) =>
            await _apiClient.PostAsync<AssignRankToMemberReq, object>("network/assignRankToMember", req);

        public async Task RemoveRankFromMember(RemoveRankFromMemberReq req) =>
            await _apiClient.DeleteAsync<object>($"network/removeRankFromMember/{_networkId}/{req.UserId}/{req.RankId}");

        public async Task<List<NetworkMember>> GetMembers(GetMembersReq req) =>
            await _apiClient.GetAsync<List<NetworkMember>>($"network/getMembers?networkId={_networkId}");
        #endregion

        #region Moderation
        public async Task KickMember(KickMemberReq req) =>
            await _apiClient.PostAsync<KickMemberReq, object>("network/kickMember", req);

        public async Task BanMember(BanMemberReq req) =>
            await _apiClient.PostAsync<BanMemberReq, object>("network/banMember", req);

        public async Task UnbanMember(UnbanMemberReq req) =>
            await _apiClient.DeleteAsync<object>($"network/unbanMember/{_networkId}/{req.UserId}");

        public async Task<List<BannedMember>> GetBannedMembers(GetBannedMembersReq req) =>
            await _apiClient.GetAsync<List<BannedMember>>($"network/getBannedMembers?networkId={_networkId}");
        #endregion

        #region Permissions & Overwrites
        public async Task ModifyRankPermissions(ModifyPermissionsReq req) =>
            await _apiClient.PatchAsync<ModifyPermissionsReq, object>("network/modifyPermissions", req);

        public async Task OverwritePermission(OverwritePermissionReq req) =>
            await _apiClient.PostAsync<OverwritePermissionReq, object>("network/overwritePermission", req);

        public async Task OverwriteChannelPermission(OverwriteChannelPermissionReq req) =>
            await _apiClient.PostAsync<OverwriteChannelPermissionReq, object>("network/overwriteChannelPermission", req);

        public async Task<List<PermissionOverwrite>> GetOverwrites(GetOverwritesReq req) =>
            await _apiClient.GetAsync<List<PermissionOverwrite>>($"network/getOverwrites?networkId={_networkId}");

        public async Task<List<PermissionOverwrite>> GetChannelOverwrites(GetChannelOverwritesReq req) =>
            await _apiClient.GetAsync<List<PermissionOverwrite>>($"network/getChannelOverwrites?channelId={req.ChannelId}");
        #endregion

        #region Settings & Real-time
        public async Task UploadNewPic(UploadNewPictureReq req) =>
            await _apiClient.PostAsync<UploadNewPictureReq, object>("v2/network/uploadNewPic", req);

        public async Task ChangeVisibility(ChangeVisibilityReq req) =>
            await _apiClient.PatchAsync<ChangeVisibilityReq, object>("network/changeVisibility", req);

        public async Task EditName(EditNameReq req) =>
            await _apiClient.PatchAsync<EditNameReq, object>("network/editName", req);

        public async Task ToggleMute(ToggleNetworkMuteReq req) =>
            await _apiClient.PostAsync<ToggleNetworkMuteReq, object>("network/toggleNetMute", req);

        public async Task JoinWebSocketRoom(JoinWebSocketRoomReq req) =>
            await _apiClient.PostAsync<JoinWebSocketRoomReq, object>("v2/network/joinWebSocketRoom", req);
        #endregion
    }
}