module data_cache #(
    // 异步FIFO参数（IR→系统时钟域）
    parameter ASYNC_FIFO_DEPTH    = 1024,  // 异步FIFO深度
    parameter ASYNC_FIFO_DATA_W   = 27,    // 27bit=1(ir_valid)+1(ir_vs)+1(ir_hs)+8(ch0)+8(ch1)+8(ch2)
    // 同步FIFO参数（系统时钟域，256bit数据缓存）
    parameter SYNC_FIFO_DEPTH     = 2048,  // 同步FIFO深度（适配256x256图像）
    parameter SYNC_FIFO_DATA_W    = 256,   // 同步FIFO数据位宽（AXI写数据位宽）
    // 直方图RAM参数（1x256，每个通道1个）
    parameter HIST_RAM_DEPTH      = 256,   // 直方图RAM深度（0~255，对应8bit像素值）
    parameter HIST_RAM_DATA_W     = 1,     // 直方图RAM数据位宽（1bit：存在标记）
    // AXI参数
    parameter AXI_ID_W            = 8,     // AXI AW/W ID位宽
    parameter AXI_ADDR_W          = 32,    // AXI地址位宽
    parameter AXI_DATA_W          = 256,   // AXI数据位宽（与SYNC_FIFO_DATA_W一致）
    parameter AXI_STRB_W          = AXI_DATA_W / 8  // AXI WSTRB位宽（32bit）
) (
    // -------------------------- Common 端口 --------------------------
    input  wire                        clk,                // 系统时钟（AXI/控制逻辑时钟）
    input  wire                        rst_n,              // 系统复位（低有效，同步clk）
    // -------------------------- 配置信号端口 --------------------------
    input  wire                        ipa_en,             // IPA总使能
    input  wire                        update_src_trig,    // 更新原始图像触发（高有效）
    input  wire                        input_pixel_type,   // 输入像素类型：0=Gray，1=RGB
    input  wire [15:0]                 src_pixel_height,   // 原始图像高度
    input  wire [15:0]                 src_pixel_width,    // 原始图像宽度
    input  wire [15:0]                 histogram_low_num,  // 直方图低位数（计算min用）
    input  wire [15:0]                 histogram_high_num, // 直方图高位数（计算max用）
    output reg                         src_image_cache_done, // 原始图像缓存完成（高有效）
    // -------------------------- 连接Windowed模块端口 --------------------------
    output reg [7:0]                   dwidth_conv_min_ch0, // CH0归一化min值
    output reg [7:0]                   dwidth_conv_max_ch0, // CH0归一化max值
    output reg [7:0]                   dwidth_conv_min_ch1, // CH1归一化min值
    output reg [7:0]                   dwidth_conv_max_ch1, // CH1归一化max值
    output reg [7:0]                   dwidth_conv_min_ch2, // CH2归一化min值
    output reg [7:0]                   dwidth_conv_max_ch2, // CH2归一化max值
    // -------------------------- IR图像输入端口（IR时钟域） --------------------------
    input  wire                        ir_clk,             // IR像素同步时钟
    input  wire                        ir_valid,           // IR像素有效信号
    input  wire                        ir_vs,              // IR垂直同步（帧起始）
    input  wire                        ir_hs,              // IR水平同步（行起始）
    input  wire [7:0]                  ir_ch0,             // IR CH0数据（Gray时有效）
    input  wire [7:0]                  ir_ch1,             // IR CH1数据（RGB时有效）
    input  wire [7:0]                  ir_ch2,             // IR CH2数据（RGB时有效）
    // -------------------------- AXI写总线端口（系统时钟域） --------------------------
    output reg [AXI_ID_W-1:0]          axi_m_awid,         // AXI AW通道ID
    output reg [AXI_ADDR_W-1:0]        axi_m_awaddr,       // AXI AW通道地址（SRAM起始地址）
    output reg [3:0]                   axi_m_awlen,        // AXI AW通道突发长度（0=1拍）
    output reg [2:0]                   axi_m_awsize,       // AXI AW通道数据宽度（5=32字节=256bit）
    output reg [1:0]                   axi_m_awburst,      // AXI AW通道突发类型（0=INCR）
    output reg                         axi_m_awlock,       // AXI AW通道锁定（0=普通）
    output reg [3:0]                   axi_m_awcache,      // AXI AW通道缓存属性（0=非缓存）
    output reg [2:0]                   axi_m_awprot,       // AXI AW通道保护属性（0=普通）
    output reg [3:0]                   axi_m_awqos,        // AXI AW通道QoS（0=默认）
    output reg                         axi_m_awvalid,      // AXI AW通道有效
    input  wire                        axi_m_awready,      // AXI AW通道就绪
    output reg [AXI_ID_W-1:0]          axi_m_wid,          // AXI W通道ID（与AW一致）
    output reg [AXI_DATA_W-1:0]        axi_m_wdata,        // AXI W通道数据（256bit）
    output reg [AXI_STRB_W-1:0]        axi_m_wstrb,        // AXI W通道字节使能（全1=有效）
    output reg                         axi_m_wlast,        // AXI W通道突发结束标记
    output reg                         axi_m_wvalid,       // AXI W通道有效
    input  wire                        axi_m_wready,       // AXI W通道就绪
    input  wire [AXI_ID_W-1:0]        axi_m_bid,          // AXI B通道ID
    input  wire [1:0]                  axi_m_bresp,        // AXI B通道响应（0=OKAY）
    input  wire                        axi_m_bvalid,       // AXI B通道有效
    output reg                         axi_m_bready        // AXI B通道就绪
);

// -------------------------- 内部信号定义 --------------------------
// 1. 复位同步（跨时钟域复位处理）
wire        rst_n_ir;          // IR时钟域同步后的复位
wire        rst_n_sys;         // 系统时钟域同步后的复位

// 2. 异步FIFO信号（IR→系统时钟域）
wire        async_fifo_wr_en;  // 异步FIFO写使能（IR时钟域）
wire [ASYNC_FIFO_DATA_W-1:0]   async_fifo_wr_data;  // 异步FIFO写数据（IR时钟域）
wire        async_fifo_full;   // 异步FIFO满（IR时钟域）
wire        async_fifo_rd_en;  // 异步FIFO读使能（系统时钟域）
wire [ASYNC_FIFO_DATA_W-1:0]   async_fifo_rd_data;  // 异步FIFO读数据（系统时钟域）
wire        async_fifo_empty;  // 异步FIFO空（系统时钟域）

// 3. 跨域后像素信号（系统时钟域）
wire        ir_valid_sys;      // 跨域后像素有效
wire        ir_vs_sys;         // 跨域后帧起始
wire        ir_hs_sys;         // 跨域后行起始
wire [7:0]  ir_ch0_sys;        // 跨域后CH0数据
wire [7:0]  ir_ch1_sys;        // 跨域后CH1数据
wire [7:0]  ir_ch2_sys;        // 跨域后CH2数据
reg         flag;

// 4. 直方图控制信号
wire        hist_rst;          // 直方图RAM复位（帧起始/更新触发）
wire        hist_wr_en_ch0;    // CH0直方图写使能
wire [7:0]  hist_wr_addr_ch0;  // CH0直方图写地址（像素值）
wire        hist_wr_en_ch1;    // CH1直方图写使能
wire [7:0]  hist_wr_addr_ch1;  // CH1直方图写地址（像素值）
wire        hist_wr_en_ch2;    // CH2直方图写使能
wire [7:0]  hist_wr_addr_ch2;  // CH2直方图写地址（像素值）
reg         hist_calc_en;      // 直方图min/max计算使能（帧结束后）
wire        hist_calc_done;    // 直方图min/max计算完成

// 5. 数据拼接信号
wire        assemble_en;       // 数据拼接使能
wire        assemble_done;     // 数据拼接完成（256bit就绪）
wire [255:0] assemble_data;    // 拼接后256bit数据

// 6. 同步FIFO信号（系统时钟域）
wire        sync_fifo_wr_en;   // 同步FIFO写使能
wire [255:0] sync_fifo_wr_data;// 同步FIFO写数据（拼接后256bit）
wire        sync_fifo_full;    // 同步FIFO满
wire        sync_fifo_rd_en;   // 同步FIFO读使能
wire [255:0] sync_fifo_rd_data;// 同步FIFO读数据
wire        sync_fifo_empty;   // 同步FIFO空

// 7. 帧计数与状态信号
reg [15:0]  col_cnt;           // 列计数器（像素宽度计数）
reg [15:0]  row_cnt;           // 行计数器（像素高度计数）
reg         frame_active;      // 帧活跃标记（IR_VS后到帧结束）
reg         axi_write_busy;    // AXI写事务忙标记
wire        axi_write_done;   // 来自 axi_write_ctrl 的写完成标志 

// 8. 状态机定义
// typedef enum logic [2:0] {
//     S_IDLE,          // 空闲（等待IPA使能）
//     S_WAIT_VS,       // 等待帧起始（IR_VS）
//     S_RECEIVE_DATA,  // 接收像素数据（写直方图+拼接）
//     S_WRITE_FIFO,    // 拼接完成写同步FIFO
//     S_WAIT_AXI,      // 等待AXI写完成
//     S_FRAME_DONE     // 帧缓存完成（置位src_image_cache_done）
// } data_cache_state_t;

localparam [3:0] S_IDLE         = 3'b000;
localparam [3:0] S_WAIT_VS      = 3'b001;
localparam [3:0] S_RECEIVE_DATA = 3'b010;
localparam [3:0] S_WRITE_FIFO   = 3'b011;
localparam [3:0] S_WAIT_AXI     = 3'b100;
localparam [3:0] S_FRAME_DONE   = 3'b101;

reg [2:0]   curr_state;
reg [2:0]   next_state;


// -------------------------- 子模块实例化 --------------------------
// 1. 复位同步（确保跨时钟域复位稳定）
rst_sync #(
    .SYNC_STAGE(2)  // 2级同步
) u_rst_sync_ir (
    .clk(ir_clk),
    .rst_n_in(rst_n),
    .rst_n_out(rst_n_ir)
);

rst_sync #(
    .SYNC_STAGE(2)
) u_rst_sync_sys (
    .clk(clk),
    .rst_n_in(rst_n),
    .rst_n_out(rst_n_sys)
);

// 2. 异步FIFO（IR时钟域→系统时钟域，传输像素数据+控制信号）
async_fifo #(
    .FIFO_DEPTH(ASYNC_FIFO_DEPTH),
    .DATA_WIDTH(ASYNC_FIFO_DATA_W)
) u_async_fifo (
    // 写端口（IR时钟域）
    .wr_clk(ir_clk),
    .wr_rst_n(rst_n_ir),
    .wr_en(async_fifo_wr_en),
    .wr_data(async_fifo_wr_data),
    .full(async_fifo_full),
    // 读端口（系统时钟域）
    .rd_clk(clk),
    .rd_rst_n(rst_n_sys),
    .rd_en(async_fifo_rd_en),
    .rd_data(async_fifo_rd_data),
    .empty(async_fifo_empty)
);

// 3. 直方图控制模块（统计CH0/CH1/CH2直方图，计算min/max）
histogram_ctrl #(
    .HIST_RAM_DEPTH(HIST_RAM_DEPTH),
    .HIST_RAM_DATA_W(HIST_RAM_DATA_W)
) u_histogram_ctrl (
    .clk(clk),
    .rst_n(rst_n_sys),
    .hist_rst(hist_rst),
    .input_pixel_type(input_pixel_type),
    .hist_wr_en_ch0(hist_wr_en_ch0),
    .hist_wr_addr_ch0(hist_wr_addr_ch0),
    .hist_wr_en_ch1(hist_wr_en_ch1),
    .hist_wr_addr_ch1(hist_wr_addr_ch1),
    .hist_wr_en_ch2(hist_wr_en_ch2),
    .hist_wr_addr_ch2(hist_wr_addr_ch2),
    .histogram_low_num(histogram_low_num),
    .histogram_high_num(histogram_high_num),
    .calc_en(hist_calc_en),
    .calc_done(hist_calc_done),
    .dwidth_conv_min_ch0(dwidth_conv_min_ch0),
    .dwidth_conv_max_ch0(dwidth_conv_max_ch0),
    .dwidth_conv_min_ch1(dwidth_conv_min_ch1),
    .dwidth_conv_max_ch1(dwidth_conv_max_ch1),
    .dwidth_conv_min_ch2(dwidth_conv_min_ch2),
    .dwidth_conv_max_ch2(dwidth_conv_max_ch2)
);

// 4. 数据拼接模块（Gray:32x8bit→256bit；RGB:8x32bit→256bit）
data_assemble #(
    .PIXEL_WIDTH(8),          // 单通道像素位宽
    .GRAY_PIXEL_CNT(32),      // Gray模式拼接像素数（32x8bit=256bit）
    .RGB_PIXEL_CNT(8)         // RGB模式拼接像素数（8x32bit=256bit）
) u_data_assemble (
    .clk(clk),
    .rst_n(rst_n_sys),
    .en(assemble_en),
    .input_pixel_type(input_pixel_type),
    .ir_ch0(ir_ch0_sys),
    .ir_ch1(ir_ch1_sys),
    .ir_ch2(ir_ch2_sys),
    .pixel_valid(async_fifo_rd_data[26]),
    .done(assemble_done),
    .assembled_data(assemble_data)
);

// 5. 同步FIFO（缓存拼接后的256bit数据，适配AXI写速度）
sync_fifo #(
    .FIFO_DEPTH(SYNC_FIFO_DEPTH),
    .DATA_WIDTH(SYNC_FIFO_DATA_W)
) u_sync_fifo (
    .clk(clk),
    .rst_n(rst_n_sys),
    .wr_en(sync_fifo_wr_en),
    .wr_data(sync_fifo_wr_data),
    .full(sync_fifo_full),
    .rd_en(sync_fifo_rd_en),
    .rd_data(sync_fifo_rd_data),
    .empty(sync_fifo_empty)
);

// 6. AXI写控制模块（从同步FIFO读数据，发起AXI写事务）
axi_write_ctrl #(
    .AXI_ID_W(AXI_ID_W),
    .AXI_ADDR_W(AXI_ADDR_W),
    .AXI_DATA_W(AXI_DATA_W),
    .AXI_STRB_W(AXI_STRB_W)
) u_axi_write_ctrl (
    .clk(clk),
    .rst_n(rst_n_sys),
    .start_en(!sync_fifo_empty && !axi_write_busy),  // FIFO非空且AXI空闲时启动
    .sram_base_addr(32'h0000_0000),                  // SRAM基地址（可配置）
    .fifo_rd_data(sync_fifo_rd_data),
    .fifo_empty(sync_fifo_empty),
    .fifo_rd_en(sync_fifo_rd_en),
    .axi_m_awid(axi_m_awid),
    .axi_m_awaddr(axi_m_awaddr),
    .axi_m_awlen(axi_m_awlen),
    .axi_m_awsize(axi_m_awsize),
    .axi_m_awburst(axi_m_awburst),
    .axi_m_awlock(axi_m_awlock),
    .axi_m_awcache(axi_m_awcache),
    .axi_m_awprot(axi_m_awprot),
    .axi_m_awqos(axi_m_awqos),
    .axi_m_awvalid(axi_m_awvalid),
    .axi_m_awready(axi_m_awready),
    .axi_m_wid(axi_m_wid),
    .axi_m_wdata(axi_m_wdata),
    .axi_m_wstrb(axi_m_wstrb),
    .axi_m_wlast(axi_m_wlast),
    .axi_m_wvalid(axi_m_wvalid),
    .axi_m_wready(axi_m_wready),
    .axi_m_bid(axi_m_bid),
    .axi_m_bresp(axi_m_bresp),
    .axi_m_bvalid(axi_m_bvalid),
    .axi_m_bready(axi_m_bready),
    .axi_busy(axi_write_busy),
    .axi_done(axi_write_done)
);


// -------------------------- 核心逻辑实现 --------------------------
// assign flag = (col_cnt == src_pixel_width-1'd1);
assign axi_write_done = (axi_m_bvalid && axi_m_bready);
// 1. 异步FIFO写控制（IR时钟域）
assign async_fifo_wr_data = {ir_valid, ir_vs, ir_hs, ir_ch2, ir_ch1, ir_ch0};
assign async_fifo_wr_en = ir_valid && !async_fifo_full && ipa_en;  // 像素有效且FIFO未满

// 2. 异步FIFO读控制（系统时钟域）
assign async_fifo_rd_en = !async_fifo_empty  && 
                          (curr_state == S_WAIT_VS || frame_active) && !flag;  // 帧活跃且FIFO非空

// 3. 跨域后信号解析（系统时钟域）
assign ir_valid_sys = async_fifo_rd_data[26] && !flag;  // [26] = ir_valid
assign ir_vs_sys    = async_fifo_rd_data[25];  // [25] = ir_vs
assign ir_hs_sys    = async_fifo_rd_data[24];  // [24] = ir_hs
assign ir_ch2_sys   = async_fifo_rd_data[23:16];// [23:16] = ir_ch2
assign ir_ch1_sys   = async_fifo_rd_data[15:8]; // [15:8] = ir_ch1
assign ir_ch0_sys   = async_fifo_rd_data[7:0];  // [7:0] = ir_ch0

// 4. 直方图写控制（系统时钟域）
assign hist_rst = update_src_trig || ir_vs_sys;  // 更新触发或帧起始时复位直方图
assign hist_wr_en_ch0 = ir_valid_sys && frame_active;  // CH0始终写（Gray/RGB均有效）
assign hist_wr_addr_ch0 = ir_ch0_sys;
assign hist_wr_en_ch1 = ir_valid_sys && frame_active && (input_pixel_type == 1'b1);  // RGB时写CH1
assign hist_wr_addr_ch1 = ir_ch1_sys;
assign hist_wr_en_ch2 = ir_valid_sys && frame_active && (input_pixel_type == 1'b1);  // RGB时写CH2
assign hist_wr_addr_ch2 = ir_ch2_sys;
//assign hist_calc_en = (row_cnt == src_pixel_height-1'd1) && (col_cnt == src_pixel_width-1'd1);  // 帧结束后计算min/max

// 5. 数据拼接使能控制
assign assemble_en = frame_active && ir_valid_sys && !ir_vs_sys;

// 6. 同步FIFO写控制
assign sync_fifo_wr_en = assemble_done && !sync_fifo_full;
assign sync_fifo_wr_data = assemble_data;

// 7. 帧计数逻辑 - 修复frame_active激活（关键：不依赖frame_active读FIFO）
always @(posedge clk or negedge rst_n_sys) begin
    if (!rst_n_sys) begin
        col_cnt <= 16'd0;
        row_cnt <= 16'd0;
        frame_active <= 1'b0;
    end else if (update_src_trig) begin
        col_cnt <= 16'd0;
        row_cnt <= 16'd0;
        frame_active <= 1'b0;
    end else if (ir_vs_sys && curr_state == S_WAIT_VS) begin
        // WAIT_VS状态下，ir_vs_sys=1 → 激活frame_active
        col_cnt <= 16'd0;
        row_cnt <= 16'd0;
        frame_active <= 1'b1;
    end else if (curr_state == S_RECEIVE_DATA) begin
        // RECEIVE_DATA状态下保持frame_active=1，直到帧结束
        frame_active <= 1'b1;
        if (ir_valid_sys && !ir_vs_sys) begin
            col_cnt <= col_cnt + 16'd1;
            if (col_cnt == src_pixel_width - 16'd1) begin
                col_cnt <= 16'd0;
                row_cnt <= row_cnt + 16'd1;
                if (row_cnt == src_pixel_height - 16'd1) begin
                    frame_active <= 1'b0;
                end
            end
        end
    end else begin
        frame_active <= 1'b0;
    end
end

// 8. 状态机时序逻辑
always @(posedge clk or negedge rst_n_sys) begin
    if (!rst_n_sys) begin
        curr_state <= S_IDLE;
    end else begin
        curr_state <= next_state;
    end
end

// 9. 状态机组合逻辑（状态转移）
always @(*) begin
    next_state = curr_state;
    case (curr_state)
        S_IDLE: begin
            // 等待IPA使能
            if (ipa_en && !update_src_trig) begin
                next_state = S_WAIT_VS;
            end
        end
        S_WAIT_VS: begin
            // 等待帧起始（IR_VS）
            if (ir_vs_sys) begin
                next_state = S_RECEIVE_DATA;
            end else if (update_src_trig) begin
                next_state = S_IDLE;
            end
        end
        S_RECEIVE_DATA: begin
            // 接收数据：直到帧结束（行/列计数满）
            if ((row_cnt == src_pixel_height-1'd1) && (col_cnt == src_pixel_width-1'd1)) begin
                next_state = S_WRITE_FIFO;
            end else if (update_src_trig) begin
                next_state = S_IDLE;
            end
        end
        S_WRITE_FIFO: begin
            // 条件1：同步FIFO已空（数据已全部读出到AXI控制器），但AXI仍在忙碌 → 等待AXI完成
            if (sync_fifo_empty && axi_write_busy) begin
                next_state = S_WAIT_AXI;
            end
            // 条件2：同步FIFO已空，且AXI已完成所有写操作 → 直接进入帧完成
            else if (sync_fifo_empty && !axi_write_busy) begin
                next_state = S_FRAME_DONE;
            end
            // 条件3：收到更新触发 → 强制回到IDLE
            else if (update_src_trig) begin
                next_state = S_IDLE;
            end
        end
        S_WAIT_AXI: begin
            // AXI写完成后进入帧完成状态
            if (axi_write_done) begin
                next_state = S_FRAME_DONE;
            end
            // 收到更新触发 → 强制回到IDLE
            else if (update_src_trig) begin
                next_state = S_IDLE;
            end
        end
        S_FRAME_DONE: begin
            // 帧完成：保持1拍后回到等待VS（支持连续帧）
            if (src_image_cache_done) begin
                next_state = S_WAIT_VS;
            end else begin
                next_state = S_FRAME_DONE;
            end
        end
    endcase
end

// 10. 状态机输出逻辑（控制各模块行为）
always @(posedge clk or negedge rst_n_sys) begin
    if (!rst_n_sys) begin
        src_image_cache_done <= 1'b0;
    end else begin
        src_image_cache_done <= 1'b0;
        case (curr_state)
            S_FRAME_DONE: begin
                // 帧完成：置位缓存完成信号，并等待直方图计算完成
                src_image_cache_done <= hist_calc_done;
            end
            default: begin
                src_image_cache_done <= 1'b0;
            end
        endcase
    end
end

always @(posedge clk or negedge rst_n_sys) begin
    if (!rst_n_sys) begin
        hist_calc_en <= 'd0;
    end else begin
        hist_calc_en <= (row_cnt == src_pixel_height-1'd1) && (col_cnt == src_pixel_width-1'd1);
    end

end

// always @(posedge clk or negedge rst_n_sys) begin
//     if (!rst_n_sys) begin
//         assemble_en <= 'd0;
//     end else begin
//         assemble_en <= frame_active && ir_valid_sys && !ir_vs_sys;
//     end

// end
reg [1:0] flag_cnt;
always @(posedge clk or negedge rst_n_sys) begin
    if (!rst_n_sys) begin
        flag <= 'd0;
        flag_cnt <='d0;
    end else if (flag == 1'b1)begin
        flag_cnt <= flag_cnt + 1'b1;
        if (flag_cnt == 2'd2) begin
            flag <= 'd0;
            flag_cnt <='d0;
        end
    end else if (col_cnt == src_pixel_width-1'd1) begin
        flag <= 1'b1;
    end
end


endmodule