#pragma once

#include "Dom.h"         // 支配树分析依赖
#include "Loop.h"        // 循环分析依赖
#include "Liveness.h"    // 活跃性分析依赖
#include "AliasAnalysis.h" // 别名分析依赖
#include "SideEffectAnalysis.h" // 副作用分析依赖
#include "CallGraphAnalysis.h" // 调用图分析依赖
#include "IR.h"          // IR定义
#include "Pass.h"        // Pass框架
#include <algorithm>
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <vector>

namespace sysy {

// 前向声明
class LoopCharacteristicsResult;

/**
 * @brief 循环特征信息结构 - 基础循环分析阶段
 * 存储循环的基本特征信息，为后续精确分析提供基础
 */
struct LoopCharacteristics {
  Loop* loop;                                    // 关联的循环对象

  // ========== 基础循环形式分析 ==========
  bool isCountingLoop;                         // 是否为计数循环 (for i=0; i<n; i++)
  bool isSimpleForLoop;                        // 是否为简单for循环
  bool hasComplexControlFlow;                  // 是否有复杂控制流 (break, continue)
  bool isInnermost;                            // 是否为最内层循环
  
  // ========== 基础归纳变量分析 ==========
  std::vector<Value*> basicInductionVars;       // 基本归纳变量
  std::map<Value*, int> inductionSteps;         // 归纳变量的步长（简化）
  
  // ========== 基础循环不变量分析 ==========
  std::set<Value*> loopInvariants;              // 循环不变量
  std::set<Instruction*> invariantInsts;       // 可提升的不变指令
  
  // ========== 基础边界分析 ==========
  std::optional<int> staticTripCount;          // 静态循环次数（如果可确定）
  bool hasKnownBounds;                         // 是否有已知边界
  
  // ========== 基础纯度和副作用分析 ==========
  bool isPure;                                 // 是否为纯循环（无副作用）
  bool accessesOnlyLocalMemory;                // 是否只访问局部内存
  bool hasNoMemoryAliasConflicts;              // 是否无内存别名冲突
  
  // ========== 基础内存访问模式分析 ==========
  struct MemoryAccessPattern {
    std::vector<Instruction*> loadInsts;       // load指令列表
    std::vector<Instruction*> storeInsts;      // store指令列表
    bool isArrayParameter;                     // 是否为数组参数访问
    bool isGlobalArray;                        // 是否为全局数组访问
    bool hasConstantIndices;                   // 是否使用常量索引
  };
  std::map<Value*, MemoryAccessPattern> memoryPatterns; // 内存访问模式
  
  // ========== 基础性能特征 ==========
  size_t instructionCount;                     // 循环体指令数
  size_t memoryOperationCount;                 // 内存操作数
  size_t arithmeticOperationCount;             // 算术操作数
  double computeToMemoryRatio;                 // 计算与内存操作比率
  
  // ========== 基础优化提示 ==========
  bool benefitsFromUnrolling;                  // 是否适合循环展开
  int suggestedUnrollFactor;                   // 建议的展开因子
  
  // 构造函数 - 简化的基础分析初始化
  LoopCharacteristics(Loop* l) : loop(l), 
    isCountingLoop(false), isSimpleForLoop(false), hasComplexControlFlow(false),
    isInnermost(false), hasKnownBounds(false), isPure(false), 
    accessesOnlyLocalMemory(false), hasNoMemoryAliasConflicts(false),
    benefitsFromUnrolling(false), suggestedUnrollFactor(1), 
    instructionCount(0), memoryOperationCount(0),
    arithmeticOperationCount(0), computeToMemoryRatio(0.0) {}
};

/**
 * @brief 循环特征分析结果类
 * 包含函数中所有循环的特征信息，并提供查询接口
 */
class LoopCharacteristicsResult : public AnalysisResultBase {
public:
  LoopCharacteristicsResult(Function *F) : AssociatedFunction(F) {}
  ~LoopCharacteristicsResult() override = default;

  // ========== 基础接口 ==========
  
  /**
   * 添加循环特征信息
   */
  void addLoopCharacteristics(std::unique_ptr<LoopCharacteristics> characteristics) {
    auto* loop = characteristics->loop;
    CharacteristicsMap[loop] = std::move(characteristics);
  }
  
  /**
   * 获取指定循环的特征信息
   */
  const LoopCharacteristics* getCharacteristics(Loop* loop) const {
    auto it = CharacteristicsMap.find(loop);
    return (it != CharacteristicsMap.end()) ? it->second.get() : nullptr;
  }
  
  /**
   * 获取所有循环特征信息
   */
  const std::map<Loop*, std::unique_ptr<LoopCharacteristics>>& getAllCharacteristics() const {
    return CharacteristicsMap;
  }

  // ========== 核心查询接口 ==========
  
  /**
   * 获取所有计数循环
   */
  std::vector<Loop*> getCountingLoops() const {
    std::vector<Loop*> result;
    for (const auto& [loop, chars] : CharacteristicsMap) {
      if (chars->isCountingLoop) {
        result.push_back(loop);
      }
    }
    return result;
  }
  
  /**
   * 获取所有纯循环（无副作用）
   */
  std::vector<Loop*> getPureLoops() const {
    std::vector<Loop*> result;
    for (const auto& [loop, chars] : CharacteristicsMap) {
      if (chars->isPure) {
        result.push_back(loop);
      }
    }
    return result;
  }
  
  /**
   * 获取所有只访问局部内存的循环
   */
  std::vector<Loop*> getLocalMemoryOnlyLoops() const {
    std::vector<Loop*> result;
    for (const auto& [loop, chars] : CharacteristicsMap) {
      if (chars->accessesOnlyLocalMemory) {
        result.push_back(loop);
      }
    }
    return result;
  }
  
  /**
   * 获取所有无内存别名冲突的循环
   */
  std::vector<Loop*> getNoAliasConflictLoops() const {
    std::vector<Loop*> result;
    for (const auto& [loop, chars] : CharacteristicsMap) {
      if (chars->hasNoMemoryAliasConflicts) {
        result.push_back(loop);
      }
    }
    return result;
  }
  
  /**
   * 获取所有适合展开的循环
   */
  std::vector<Loop*> getUnrollingCandidates() const {
    std::vector<Loop*> result;
    for (const auto& [loop, chars] : CharacteristicsMap) {
      if (chars->benefitsFromUnrolling) {
        result.push_back(loop);
      }
    }
    return result;
  }
  
  /**
   * 根据热度排序循环 (用于优化优先级)
   */
  std::vector<Loop*> getLoopsByHotness() const {
    std::vector<Loop*> result;
    for (const auto& [loop, chars] : CharacteristicsMap) {
      result.push_back(loop);
    }
    
    // 按循环热度排序 (嵌套深度 + 循环次数 + 指令数)
    std::sort(result.begin(), result.end(), [](Loop* a, Loop* b) {
      double hotnessA = a->getLoopHotness();
      double hotnessB = b->getLoopHotness();
      return hotnessA > hotnessB; // 降序排列
    });
    
    return result;
  }

  // ========== 基础统计接口 ==========
  
  /**
   * 获取基础优化统计信息
   */
  struct BasicOptimizationStats {
    size_t totalLoops;
    size_t countingLoops;
    size_t unrollingCandidates;
    size_t pureLoops;
    size_t localMemoryOnlyLoops;
    size_t noAliasConflictLoops;
    double avgInstructionCount;
    double avgComputeMemoryRatio;
  };
  
  BasicOptimizationStats getOptimizationStats() const {
    BasicOptimizationStats stats = {};
    stats.totalLoops = CharacteristicsMap.size();
    
    size_t totalInstructions = 0;
    double totalComputeMemoryRatio = 0.0;
    
    for (const auto& [loop, chars] : CharacteristicsMap) {
      if (chars->isCountingLoop) stats.countingLoops++;
      if (chars->benefitsFromUnrolling) stats.unrollingCandidates++;
      if (chars->isPure) stats.pureLoops++;
      if (chars->accessesOnlyLocalMemory) stats.localMemoryOnlyLoops++;
      if (chars->hasNoMemoryAliasConflicts) stats.noAliasConflictLoops++;
      
      totalInstructions += chars->instructionCount;
      totalComputeMemoryRatio += chars->computeToMemoryRatio;
    }
    
    if (stats.totalLoops > 0) {
      stats.avgInstructionCount = static_cast<double>(totalInstructions) / stats.totalLoops;
      stats.avgComputeMemoryRatio = totalComputeMemoryRatio / stats.totalLoops;
    }
    
    return stats;
  }

  // 打印分析结果
  void print() const;

private:
  Function *AssociatedFunction;                                    // 关联的函数
  std::map<Loop*, std::unique_ptr<LoopCharacteristics>> CharacteristicsMap; // 循环特征映射
};

/**
 * @brief 基础循环特征分析遍
 * 在循环规范化前执行，进行基础的循环特征分析，为后续精确分析提供基础
 */
class LoopCharacteristicsPass : public AnalysisPass {
public:
  // 唯一的 Pass ID
  static void *ID;

  LoopCharacteristicsPass() : AnalysisPass("LoopCharacteristics", Pass::Granularity::Function) {}

  // 实现 getPassID
  void *getPassID() const override { return &ID; }

  // 核心运行方法
  bool runOnFunction(Function *F, AnalysisManager &AM) override;

  // 获取分析结果
  std::unique_ptr<AnalysisResultBase> getResult() override { return std::move(CurrentResult); }

private:
  std::unique_ptr<LoopCharacteristicsResult> CurrentResult; 
  
  // ========== 核心分析方法 ==========
  void analyzeLoop(Loop* loop, LoopCharacteristics* characteristics, AnalysisManager &AM,
                   AliasAnalysisResult* aliasAnalysis, SideEffectAnalysisResult* sideEffectAnalysis);
  
  // 基础循环形式分析
  void analyzeLoopForm(Loop* loop, LoopCharacteristics* characteristics);
  
  // 基础性能指标计算
  void computePerformanceMetrics(Loop* loop, LoopCharacteristics* characteristics);
  
  // 基础纯度和副作用分析
  void analyzePurityAndSideEffects(Loop* loop, LoopCharacteristics* characteristics,
                                  SideEffectAnalysisResult* sideEffectAnalysis);
  
  // 基础归纳变量识别
  void identifyBasicInductionVariables(Loop* loop, LoopCharacteristics* characteristics);
  
  // 基础循环不变量识别
  void identifyBasicLoopInvariants(Loop* loop, LoopCharacteristics* characteristics);
  
  // 基础边界分析
  void analyzeBasicLoopBounds(Loop* loop, LoopCharacteristics* characteristics);
  
  // 基础内存访问模式分析
  void analyzeBasicMemoryAccessPatterns(Loop* loop, LoopCharacteristics* characteristics, 
                                       AliasAnalysisResult* aliasAnalysis);
  
  // 基础优化评估
  void evaluateBasicOptimizationOpportunities(Loop* loop, LoopCharacteristics* characteristics);
  
  // ========== 辅助方法 ==========
  bool isBasicInductionVariable(Value* val, Loop* loop);
  bool isBasicLoopInvariant(Value* val, Loop* loop);
  bool hasSimpleMemoryPattern(Loop* loop); // 简单的内存模式检查
};

} // namespace sysy