using System.Net;
using System.Net.Http.Json;
using System.Text.Json;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc.Testing;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;
using NSubstitute;
using Xunit;
using XiangYi.AdminApi;
using XiangYi.Application.DTOs.Requests;
using XiangYi.Application.DTOs.Responses;
using XiangYi.Application.Interfaces;

namespace XiangYi.Api.Tests.AdminApi;

/// <summary>
/// 后台金刚位管理控制器集成测试
/// </summary>
public class AdminKingKongControllerIntegrationTests : IClassFixture<WebApplicationFactory<IAdminApiMarker>>
{
    private readonly WebApplicationFactory<IAdminApiMarker> _factory;
    private readonly IAdminKingKongService _mockAdminKingKongService;

    public AdminKingKongControllerIntegrationTests(WebApplicationFactory<IAdminApiMarker> factory)
    {
        _mockAdminKingKongService = Substitute.For<IAdminKingKongService>();
        
        _factory = factory.WithWebHostBuilder(builder =>
        {
            builder.UseEnvironment("Testing");
            builder.ConfigureServices(services =>
            {
                services.RemoveAll<IAdminKingKongService>();
                services.AddSingleton(_mockAdminKingKongService);
                
                services.AddAuthentication(options =>
                {
                    options.DefaultAuthenticateScheme = AdminTestAuthHandler.AuthenticationScheme;
                    options.DefaultChallengeScheme = AdminTestAuthHandler.AuthenticationScheme;
                })
                .AddScheme<AuthenticationSchemeOptions, AdminTestAuthHandler>(
                        AdminTestAuthHandler.AuthenticationScheme, options => { });
            });
        });
    }

    /// <summary>
    /// 测试获取金刚位列�?- 未授权返�?01
    /// </summary>
    [Fact]
    public async Task GetKingKongList_WithoutAuth_ReturnsUnauthorized()
    {
        var client = _factory.CreateClient();
        var response = await client.GetAsync("/api/admin/kingkongs");
        Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
    }

    /// <summary>
    /// 测试获取金刚位列�?- 授权后成�?
    /// </summary>
    [Fact]
    public async Task GetKingKongList_WithAuth_ReturnsSuccess()
    {
        var expectedResult = new PagedResult<AdminKingKongDto>
        {
            Items = new List<AdminKingKongDto>
            {
                new AdminKingKongDto
                {
                    Id = 1,
                    Title = "会员中心",
                    IconUrl = "https://example.com/icon.png",
                    LinkType = 1,
                    LinkTypeName = "内部页面",
                    Status = 1,
                    StatusName = "启用",
                    Sort = 1
                }
            },
            Total = 1,
            PageIndex = 1,
            PageSize = 10
        };

        _mockAdminKingKongService.GetKingKongListAsync(Arg.Any<AdminKingKongQueryRequest>())
            .Returns(Task.FromResult(expectedResult));

        var client = _factory.CreateClient();
        client.DefaultRequestHeaders.Add("Authorization", "Bearer admin-token-1");

        var response = await client.GetAsync("/api/admin/kingkongs");

        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
        
        var content = await response.Content.ReadAsStringAsync();
        var result = JsonSerializer.Deserialize<ApiResponse<PagedResult<AdminKingKongDto>>>(content,
            new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
        
        Assert.NotNull(result);
        Assert.Equal(0, result.Code);
        Assert.NotNull(result.Data);
        Assert.Single(result.Data.Items);
    }


    /// <summary>
    /// 测试获取金刚位详�?- 成功
    /// </summary>
    [Fact]
    public async Task GetKingKongDetail_WithAuth_ReturnsSuccess()
    {
        var expectedResult = new AdminKingKongDto
        {
            Id = 1,
            Title = "会员中心",
            IconUrl = "https://example.com/icon.png",
            LinkType = 1,
            LinkTypeName = "内部页面",
            LinkUrl = "/pages/member/index",
            Status = 1,
            StatusName = "启用"
        };

        _mockAdminKingKongService.GetKingKongByIdAsync(1)
            .Returns(Task.FromResult(expectedResult));

        var client = _factory.CreateClient();
        client.DefaultRequestHeaders.Add("Authorization", "Bearer admin-token-1");

        var response = await client.GetAsync("/api/admin/kingkongs/1");

        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
        
        var content = await response.Content.ReadAsStringAsync();
        var result = JsonSerializer.Deserialize<ApiResponse<AdminKingKongDto>>(content,
            new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
        
        Assert.NotNull(result);
        Assert.Equal(0, result.Code);
        Assert.NotNull(result.Data);
        Assert.Equal(expectedResult.Id, result.Data.Id);
    }

    /// <summary>
    /// 测试创建金刚�?- 成功
    /// </summary>
    [Fact]
    public async Task CreateKingKong_WithAuth_ReturnsSuccess()
    {
        _mockAdminKingKongService.CreateKingKongAsync(Arg.Any<CreateKingKongRequest>(), 1)
            .Returns(Task.FromResult(100L));

        var client = _factory.CreateClient();
        client.DefaultRequestHeaders.Add("Authorization", "Bearer admin-token-1");
        
        var request = new CreateKingKongRequest
        {
            Title = "新金刚位",
            IconUrl = "https://example.com/new-icon.png",
            LinkType = 1,
            Status = 1,
            Sort = 1
        };

        var response = await client.PostAsJsonAsync("/api/admin/kingkongs", request);

        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
        
        var content = await response.Content.ReadAsStringAsync();
        var result = JsonSerializer.Deserialize<ApiResponse<long>>(content,
            new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
        
        Assert.NotNull(result);
        Assert.Equal(0, result.Code);
        Assert.Equal(100L, result.Data);
    }

    /// <summary>
    /// 测试更新金刚�?- 成功
    /// </summary>
    [Fact]
    public async Task UpdateKingKong_WithAuth_ReturnsSuccess()
    {
        _mockAdminKingKongService.UpdateKingKongAsync(1, Arg.Any<UpdateKingKongRequest>(), 1)
            .Returns(Task.FromResult(true));

        var client = _factory.CreateClient();
        client.DefaultRequestHeaders.Add("Authorization", "Bearer admin-token-1");
        
        var request = new UpdateKingKongRequest
        {
            Title = "更新后的金刚位",
            IconUrl = "https://example.com/updated-icon.png",
            LinkType = 1,
            Status = 1,
            Sort = 2
        };

        var response = await client.PutAsJsonAsync("/api/admin/kingkongs/1", request);

        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
        
        var content = await response.Content.ReadAsStringAsync();
        var result = JsonSerializer.Deserialize<ApiResponse>(content,
            new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
        
        Assert.NotNull(result);
        Assert.Equal(0, result.Code);
    }

    /// <summary>
    /// 测试删除金刚�?- 成功
    /// </summary>
    [Fact]
    public async Task DeleteKingKong_WithAuth_ReturnsSuccess()
    {
        _mockAdminKingKongService.DeleteKingKongAsync(1, 1)
            .Returns(Task.FromResult(true));

        var client = _factory.CreateClient();
        client.DefaultRequestHeaders.Add("Authorization", "Bearer admin-token-1");

        var response = await client.DeleteAsync("/api/admin/kingkongs/1");

        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
        
        var content = await response.Content.ReadAsStringAsync();
        var result = JsonSerializer.Deserialize<ApiResponse>(content,
            new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
        
        Assert.NotNull(result);
        Assert.Equal(0, result.Code);
    }

    /// <summary>
    /// 测试更新金刚位状�?- 成功
    /// </summary>
    [Fact]
    public async Task UpdateKingKongStatus_WithAuth_ReturnsSuccess()
    {
        _mockAdminKingKongService.UpdateKingKongStatusAsync(1, 2, 1)
            .Returns(Task.FromResult(true));

        var client = _factory.CreateClient();
        client.DefaultRequestHeaders.Add("Authorization", "Bearer admin-token-1");

        var response = await client.PutAsync("/api/admin/kingkongs/1/status/2", null);

        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
        
        var content = await response.Content.ReadAsStringAsync();
        var result = JsonSerializer.Deserialize<ApiResponse>(content,
            new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
        
        Assert.NotNull(result);
        Assert.Equal(0, result.Code);
    }

    /// <summary>
    /// 测试金刚位CRUD流程 - 完整流程测试
    /// </summary>
    [Fact]
    public async Task KingKongCRUD_CompleteFlow_Success()
    {
        var kingKongId = 100L;
        
        _mockAdminKingKongService.CreateKingKongAsync(Arg.Any<CreateKingKongRequest>(), 1)
            .Returns(Task.FromResult(kingKongId));
        
        _mockAdminKingKongService.GetKingKongByIdAsync(kingKongId)
            .Returns(Task.FromResult(new AdminKingKongDto
            {
                Id = kingKongId,
                Title = "测试金刚位",
                Status = 1
            }));
        
        _mockAdminKingKongService.UpdateKingKongAsync(kingKongId, Arg.Any<UpdateKingKongRequest>(), 1)
            .Returns(Task.FromResult(true));
        
        _mockAdminKingKongService.DeleteKingKongAsync(kingKongId, 1)
            .Returns(Task.FromResult(true));

        var client = _factory.CreateClient();
        client.DefaultRequestHeaders.Add("Authorization", "Bearer admin-token-1");

        // Create
        var createRequest = new CreateKingKongRequest
        {
            Title = "测试金刚位",
            IconUrl = "https://example.com/icon.png",
            LinkType = 1,
            Status = 1
        };
        var createResponse = await client.PostAsJsonAsync("/api/admin/kingkongs", createRequest);
        Assert.Equal(HttpStatusCode.OK, createResponse.StatusCode);

        // Read
        var readResponse = await client.GetAsync($"/api/admin/kingkongs/{kingKongId}");
        Assert.Equal(HttpStatusCode.OK, readResponse.StatusCode);

        // Update
        var updateRequest = new UpdateKingKongRequest
        {
            Title = "更新后的金刚位",
            IconUrl = "https://example.com/icon.png",
            LinkType = 1,
            Status = 1
        };
        var updateResponse = await client.PutAsJsonAsync($"/api/admin/kingkongs/{kingKongId}", updateRequest);
        Assert.Equal(HttpStatusCode.OK, updateResponse.StatusCode);

        // Delete
        var deleteResponse = await client.DeleteAsync($"/api/admin/kingkongs/{kingKongId}");
        Assert.Equal(HttpStatusCode.OK, deleteResponse.StatusCode);
    }
}