using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Management;
using System.Text;

namespace FileList
{
    class Program
    {
        /// <summary>
        /// 常见文本文件扩展名集合，用于内容模式判断文件是否为文本类型。
        /// 不区分大小写。
        /// </summary>
        static readonly HashSet<string> TextExtensions = new HashSet<string>(
            StringComparer.OrdinalIgnoreCase)
        {
            ".txt", ".md", ".markdown", ".html", ".htm", ".css", ".js", ".ts", ".tsx", ".jsx",
            ".json", ".xml", ".csv", ".config", ".cs", ".vb", ".cpp", ".c", ".h", ".hpp",
            ".py", ".php", ".asp", ".aspx", ".ini", ".log", ".bat", ".cmd", ".sh", ".yml",
            ".yaml", ".sql", ".svg", ".rb", ".java", ".pl", ".pm", ".go", ".rs", ".toml",
            ".lock", ".gitignore", ".gitattributes", ".editorconfig", ".env", ".proto"
        };

        /// <summary>
        /// 程序入口。支持4个位置参数，按顺序为：
        /// 1. 文件夹路径（空则当前目录）
        /// 2. 包含扩展名（|分隔）
        /// 3. 排除扩展名（|分隔）
        /// 4. 是否显示文件内容（true/false）
        /// </summary>
        static int Main(string[] args)
        {
            // 检测当前运行环境是否为 cmd 或 powershell，决定最终是否等待按键
            bool isCmdEnv = IsRunningFromCmd();

            try
            {
                // 处理帮助请求
                if (args.Length >= 1 && !string.IsNullOrEmpty(args[0]) &&
                    (args[0] == "/?" || args[0].Equals("-h", StringComparison.OrdinalIgnoreCase) ||
                     args[0].Equals("--help", StringComparison.OrdinalIgnoreCase)))
                {
                    ShowHelp();
                    if (!isCmdEnv) WaitForKey();
                    return 0;
                }

                // 解析第一个参数：文件夹路径
                string folderPath = null;
                if (args.Length >= 1 && !string.IsNullOrEmpty(args[0]))
                    folderPath = args[0];

                if (string.IsNullOrEmpty(folderPath))
                    folderPath = AppDomain.CurrentDomain.BaseDirectory; // 默认为 exe 所在目录

                // 解析第二个参数：包含扩展名列表
                string[] includeExts = null;
                if (args.Length >= 2 && !string.IsNullOrEmpty(args[1]))
                    includeExts = NormalizeExtensions(
                        args[1].Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries));

                // 解析第三个参数：排除扩展名列表
                string[] excludeExts = null;
                if (args.Length >= 3 && !string.IsNullOrEmpty(args[2]))
                    excludeExts = NormalizeExtensions(
                        args[2].Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries));

                // 解析第四个参数：是否显示文件内容
                bool showContent = false;
                if (args.Length >= 4 && !string.IsNullOrEmpty(args[3]))
                {
                    if (!bool.TryParse(args[3], out showContent))
                    {
                        Console.Error.WriteLine("Error: fourth parameter must be 'true' or 'false'.");
                        if (!isCmdEnv) WaitForKey();
                        return 1;
                    }
                }

                // 检查目录是否存在
                if (!Directory.Exists(folderPath))
                {
                    Console.Error.WriteLine($"Error: directory not found: {folderPath}");
                    if (!isCmdEnv) WaitForKey();
                    return 1;
                }

                // 检查输出路径是否是已存在的目录
                string outputFile = Path.Combine(folderPath, "FileList.txt");
                if (Directory.Exists(outputFile))
                {
                    Console.Error.WriteLine($"Error: '{outputFile}' is a directory, cannot write.");
                    if (!isCmdEnv) WaitForKey();
                    return 1;
                }

                // 根据模式生成清单
                if (showContent)
                    GenerateContentList(folderPath, outputFile, includeExts, excludeExts);
                else
                    GenerateTreeList(folderPath, outputFile, includeExts, excludeExts);

                Console.WriteLine("FileList.txt created successfully.");
                if (!isCmdEnv) WaitForKey();
                return 0;
            }
            catch (UnauthorizedAccessException ex)
            {
                Console.Error.WriteLine($"Error: access denied - {ex.Message}");
                if (!isCmdEnv) WaitForKey();
                return 1;
            }
            catch (IOException ex)
            {
                Console.Error.WriteLine($"Error: I/O error - {ex.Message}");
                if (!isCmdEnv) WaitForKey();
                return 1;
            }
            catch (Exception ex)
            {
                Console.Error.WriteLine($"Error: {ex.Message}");
                if (!isCmdEnv) WaitForKey();
                return 1;
            }
        }

        /// <summary>
        /// 显示命令行帮助信息。
        /// </summary>
        static void ShowHelp()
        {
            Console.WriteLine("FileList - List files in a directory tree.");
            Console.WriteLine("Usage:");
            Console.WriteLine("  FileList.exe [folderPath] [includeExts] [excludeExts] [showContent]");
            Console.WriteLine();
            Console.WriteLine("Parameters:");
            Console.WriteLine("  folderPath   : Target directory. Default: current directory.");
            Console.WriteLine("  includeExts  : Use '|' separated extensions (e.g. .cs|.php).");
            Console.WriteLine("                 If provided, only these extensions are listed. (ignore excludeExts)");
            Console.WriteLine("  excludeExts  : Extensions to exclude (e.g. .tmp|.log).");
            Console.WriteLine("  showContent  : 'true' to output file paths and content, 'false' for tree view.");
            Console.WriteLine();
            Console.WriteLine("Notes:");
            Console.WriteLine("  - In CMD, escape '|' with ^ or use quotes: \".cs|.php\"");
            Console.WriteLine("  - Extensions are case-insensitive and may be specified with or without leading dot.");
        }

        /// <summary>
        /// 标准化扩展名数组：去除空白，保证每个扩展名以点开头。
        /// </summary>
        static string[] NormalizeExtensions(string[] exts)
        {
            for (int i = 0; i < exts.Length; i++)
            {
                exts[i] = exts[i].Trim();
                if (!exts[i].StartsWith("."))
                    exts[i] = "." + exts[i];
            }
            return exts;
        }

        /// <summary>
        /// 通过 WMI 查询父进程，判断是否由 cmd 或 powershell 启动。
        /// 如果判断失败则默认按独立运行处理（返回 false）。
        /// </summary>
        static bool IsRunningFromCmd()
        {
            try
            {
                using (var current = Process.GetCurrentProcess())
                {
                    string query = $"Select ParentProcessId FROM Win32_Process Where ProcessId = {current.Id}";
                    using (var searcher = new ManagementObjectSearcher(query))
                    {
                        foreach (var obj in searcher.Get())
                        {
                            int parentId = Convert.ToInt32(obj["ParentProcessId"]);
                            var parent = Process.GetProcessById(parentId);
                            string name = parent.ProcessName.ToLower();
                            return name == "cmd" || name == "powershell";
                        }
                    }
                }
            }
            catch
            {
                // 无法查询时按独立运行处理
            }
            return false;
        }

        /// <summary>
        /// 独立运行时等待用户按键，防止窗口立即关闭。
        /// </summary>
        static void WaitForKey()
        {
            Console.WriteLine("Press any key to exit...");
            Console.ReadKey();
        }

        /// <summary>
        /// 生成树形结构的文件列表（不含文件内容）。
        /// </summary>
        static void GenerateTreeList(string rootPath, string outputFile, string[] includeExts, string[] excludeExts)
        {
            // 构建根节点
            var root = new TreeNode
            {
                Name = rootPath,
                IsDirectory = true,
                FullPath = rootPath
            };

            // 递归构建树，并过滤掉无匹配文件的空目录
            BuildTree(root, includeExts, excludeExts);

            var sb = new StringBuilder();
            RenderTree(root, "", true, sb); // 渲染成字符串
            File.WriteAllText(outputFile, sb.ToString(), Encoding.UTF8);
        }

        /// <summary>
        /// 生成含文件内容的列表（扁平，无目录树）。
        /// </summary>
        static void GenerateContentList(string rootPath, string outputFile, string[] includeExts, string[] excludeExts)
        {
            // 获取所有符合过滤条件的文件，并按完整路径排序（不区分大小写）
            var files = GetFilteredFiles(rootPath, includeExts, excludeExts);
            files.Sort(StringComparer.OrdinalIgnoreCase);

            using (var writer = new StreamWriter(outputFile, false, Encoding.UTF8))
            {
                foreach (var filePath in files)
                {
                    writer.WriteLine(filePath + ":");

                    try
                    {
                        var fileInfo = new FileInfo(filePath);
                        const long maxSize = 1 * 1024 * 1024; // 1 MB

                        // 文件过大则跳过内容
                        if (fileInfo.Length > maxSize)
                        {
                            writer.WriteLine("[File size exceeds 1MB, content not displayed]");
                        }
                        // 非文本文件（根据扩展名）跳过内容
                        else if (!IsTextFile(filePath))
                        {
                            writer.WriteLine("[Non-text file, content not displayed]");
                        }
                        else
                        {
                            // 读取文件全部文本（UTF-8）
                            string content = File.ReadAllText(filePath, Encoding.UTF8);
                            writer.WriteLine(content);
                        }
                    }
                    catch (UnauthorizedAccessException)
                    {
                        throw; // 权限错误直接抛出，终止程序
                    }
                    catch (IOException)
                    {
                        throw;
                    }

                    writer.WriteLine("------------------------------------------------------------");
                }
            }
        }

        /// <summary>
        /// 判断指定文件是否属于文本文件（基于扩展名）。
        /// </summary>
        static bool IsTextFile(string filePath)
        {
            string ext = Path.GetExtension(filePath);
            return TextExtensions.Contains(ext);
        }

        /// <summary>
        /// 递归构建树节点，并根据过滤条件判断是否保留该节点。
        /// 返回 true 表示该节点（目录）下至少有一个匹配文件，应保留。
        /// </summary>
        static bool BuildTree(TreeNode node, string[] includeExts, string[] excludeExts)
        {
            // 如果是文件，直接判断是否符合过滤条件
            if (!node.IsDirectory)
                return IsFileIncluded(node.FullPath, includeExts, excludeExts);

            var dirInfo = new DirectoryInfo(node.FullPath);
            FileSystemInfo[] items;
            try
            {
                items = dirInfo.GetFileSystemInfos(); // 包含隐藏文件和系统文件
            }
            catch (UnauthorizedAccessException)
            {
                throw; // 无权访问时直接抛出，由上层终止程序
            }

            var children = new List<TreeNode>();
            foreach (var item in items)
            {
                var child = new TreeNode
                {
                    Name = item.Name,
                    FullPath = item.FullName,
                    IsDirectory = (item.Attributes & FileAttributes.Directory) == FileAttributes.Directory
                };

                // 递归检查子项，只有包含匹配文件的子项才加入列表
                bool hasFiles = BuildTree(child, includeExts, excludeExts);
                if (hasFiles)
                    children.Add(child);
            }

            // 同级条目（文件+目录）按字母升序，不区分大小写
            children.Sort((a, b) => string.Compare(a.Name, b.Name, StringComparison.OrdinalIgnoreCase));
            node.Children = children;

            // 该目录是否保留：只要至少有一个子节点（文件或包含文件的子目录）
            return children.Count > 0;
        }

        /// <summary>
        /// 判断单个文件是否符合包含/排除扩展名规则。
        /// 如果指定了包含列表，则文件扩展名必须在列表中；
        /// 否则，如果指定了排除列表，文件扩展名不能在其中；
        /// 都未指定则匹配所有文件。
        /// </summary>
        static bool IsFileIncluded(string filePath, string[] includeExts, string[] excludeExts)
        {
            string ext = Path.GetExtension(filePath);
            if (includeExts != null && includeExts.Length > 0)
                return includeExts.Any(e => string.Equals(e, ext, StringComparison.OrdinalIgnoreCase));
            if (excludeExts != null && excludeExts.Length > 0)
                return !excludeExts.Any(e => string.Equals(e, ext, StringComparison.OrdinalIgnoreCase));
            return true;
        }

        /// <summary>
        /// 递归获取指定目录下所有符合过滤条件的文件完整路径（扁平列表）。
        /// </summary>
        static List<string> GetFilteredFiles(string rootPath, string[] includeExts, string[] excludeExts)
        {
            var result = new List<string>();
            var dirInfo = new DirectoryInfo(rootPath);
            FileSystemInfo[] items;
            try
            {
                items = dirInfo.GetFileSystemInfos();
            }
            catch (UnauthorizedAccessException)
            {
                throw;
            }

            foreach (var item in items)
            {
                if ((item.Attributes & FileAttributes.Directory) == FileAttributes.Directory)
                {
                    try
                    {
                        // 递归添加子目录中的文件
                        result.AddRange(GetFilteredFiles(item.FullName, includeExts, excludeExts));
                    }
                    catch (UnauthorizedAccessException)
                    {
                        throw;
                    }
                }
                else
                {
                    if (IsFileIncluded(item.FullName, includeExts, excludeExts))
                        result.Add(item.FullName);
                }
            }
            return result;
        }

        /// <summary>
        /// 递归渲染树形结构到 StringBuilder。
        /// </summary>
        /// <param name="node">当前节点</param>
        /// <param name="indent">当前行的缩进前缀</param>
        /// <param name="isLast">当前节点是否为同级最后一个（决定使用 └── 还是 ├──）</param>
        /// <param name="sb">输出缓冲</param>
        static void RenderTree(TreeNode node, string indent, bool isLast, StringBuilder sb)
        {
            // 根节点特殊处理：直接输出完整路径，不加树形符号
            if (node.IsDirectory && node.Name == node.FullPath)
            {
                sb.AppendLine(node.Name);
            }
            else
            {
                sb.Append(indent);
                sb.Append(isLast ? "└──" : "├──");
                sb.AppendLine(node.Name);
            }

            // 处理子节点
            if (node.IsDirectory && node.Children != null)
            {
                for (int i = 0; i < node.Children.Count; i++)
                {
                    bool lastChild = (i == node.Children.Count - 1);

                    // 根节点的直接子节点缩进为空（不产生多余空格）
                    string childIndent;
                    if (node.Name == node.FullPath)
                    {
                        childIndent = ""; // 根下一级无额外缩进
                    }
                    else
                    {
                        childIndent = indent + (isLast ? "    " : "│   ");
                    }

                    RenderTree(node.Children[i], childIndent, lastChild, sb);
                }
            }
        }

        /// <summary>
        /// 树节点，表示文件或目录。
        /// </summary>
        class TreeNode
        {
            public string Name;           // 文件/目录名
            public string FullPath;       // 完整路径
            public bool IsDirectory;      // 是否为目录
            public List<TreeNode> Children; // 子节点列表（仅目录有效）
        }
    }
}

// 要保存的内容和文件名
const content = "控制台导出文本测试\n换行测试";
const filename = "导出文本.txt";
// 生成文件Blob
const blob = new Blob([content], { type: "text/plain" });
// 创建下载链接
const a = document.createElement("a");
a.href = URL.createObjectURL(blob);
a.download = filename;
a.click();
URL.revokeObjectURL(a.href);

// 要保存的内容和文件名
const content = "<h1>控制台导出页面</h1>";
const filename = "导出页面.html";
// 生成文件Blob
const blob = new Blob([content], { type: "text/html" });
// 创建下载链接
const a = document.createElement("a");
a.href = URL.createObjectURL(blob);
a.download = filename;
a.click();
URL.revokeObjectURL(a.href);

// 要保存的内容和文件名
const content = {status:0, message:"无法获取IP地址"};
const filename = "导出数据.json";
// 生成文件Blob
const jsonStr = JSON.stringify(content, null, 2);
const blob = new Blob([jsonStr], { type: "application/json" });
// 创建下载链接
const a = document.createElement("a");
a.href = URL.createObjectURL(blob);
a.download = filename;
a.click();
URL.revokeObjectURL(a.href);

WITH Letters AS (
    Select 'a' AS c UNION ALL
    Select 'b' UNION ALL
    Select 'c' UNION ALL
    Select 'd' UNION ALL
    Select 'e' UNION ALL
    Select 'f' UNION ALL
    Select 'g' UNION ALL
    Select 'h' UNION ALL
    Select 'i' UNION ALL
    Select 'j' UNION ALL
    Select 'k' UNION ALL
    Select 'l' UNION ALL
    Select 'm' UNION ALL
    Select 'n' UNION ALL
    Select 'o' UNION ALL
    Select 'p' UNION ALL
    Select 'q' UNION ALL
    Select 'r' UNION ALL
    Select 's' UNION ALL
    Select 't' UNION ALL
    Select 'u' UNION ALL
    Select 'v' UNION ALL
    Select 'w' UNION ALL
    Select 'x' UNION ALL
    Select 'y' UNION ALL
    Select 'z'
)
Insert INTO DomainNameTB (DomainName)
Select L1.c + L2.c + '.com'
FROM Letters L1
CROSS JOIN Letters L2;

Insert INTO DomainNameTB (DomainName)
Select
    L1.c + L2.c + L3.c + '.com' as n
FROM Letters L1
CROSS JOIN Letters L2
CROSS JOIN Letters L3
orDER BY n ASC;

/// <summary>
/// 判断金价是否出现急涨
/// </summary>
/// <param name="prices">金价数组，按时间从旧到新排列（索引0最早，索引Length-1最新）</param>
/// <param name="sharpRiseThreshold">急涨阈值：最新价与前面某价格的差值≥此值则视为急涨</param>
/// <param name="maxPullbackTolerance">反向下跌容忍阈值：连续下跌区间的头尾最大差值</param>
/// <returns>是否急涨</returns>
public static bool IsGoldPriceSharpRise(decimal[] prices, decimal sharpRiseThreshold, decimal maxPullbackTolerance)
{
    if (prices == null || prices.Length < 2)
        return false;

    decimal latestPrice = prices[prices.Length - 1];
    int i = prices.Length - 2;

    while (i >= 0)
    {
        // 1. 先检查当前价格是否已经满足急涨条件
        decimal riseAmount = latestPrice - prices[i];
        if (riseAmount >= sharpRiseThreshold)
        {
            return true;
        }

        // 2. 检测是否进入连续下跌区间
        if (prices[i] > prices[i + 1])
        {
            // 记录下跌区间的右端点（最晚时间，区间最低点位置）
            int pullbackEndIndex = i + 1;

            // 继续往左找，直到下跌趋势结束
            i--;
            while (i >= 0 && prices[i] >= prices[i + 1])
            {
                i--;
            }

            // 此时i+1是下跌区间的左端点（最早时间，区间最高点位置）
            int pullbackStartIndex = i + 1;
            decimal pullbackHigh = prices[pullbackStartIndex];
            decimal pullbackLow = prices[pullbackEndIndex];
            decimal totalPullback = pullbackHigh - pullbackLow;

            // 3. 检查整个下跌区间的总跌幅是否超过容忍度
            if (totalPullback > maxPullbackTolerance)
            {
                return false;
            }

            // 下跌区间处理完毕，继续往前遍历
            continue;
        }

        // 没有下跌，继续往前推
        i--;
    }

    // 遍历完所有价格都未达到急涨条件
    return false;
}

/// <summary>
/// 判断金价是否出现急跌
/// </summary>
/// <param name="prices">金价数组，按时间从旧到新排列（索引0最早，索引Length-1最新）</param>
/// <param name="sharpDropThreshold">急跌阈值：前面某价格与最新价的差值≥此值则视为急跌</param>
/// <param name="maxReboundTolerance">反向上涨容忍阈值：连续上涨区间的头尾最大差值</param>
/// <returns>是否急跌</returns>
public static bool IsGoldPriceSharpDrop(decimal[] prices, decimal sharpDropThreshold, decimal maxReboundTolerance)
{
    if (prices == null || prices.Length < 2)
        return false;

    decimal latestPrice = prices[prices.Length - 1];
    int i = prices.Length - 2;

    while (i >= 0)
    {
        // 1. 先检查当前价格是否已经满足急跌条件
        decimal dropAmount = prices[i] - latestPrice;
        if (dropAmount >= sharpDropThreshold)
        {
            return true;
        }

        // 2. 检测是否进入连续上涨区间（急跌时的反向趋势）
        if (prices[i] < prices[i + 1])
        {
            // 记录上涨区间的右端点（最晚时间，区间最高点位置）
            int reboundEndIndex = i + 1;

            // 继续往左找，直到上涨趋势结束
            i--;
            while (i >= 0 && prices[i] <= prices[i + 1])
            {
                i--;
            }

            // 此时i+1是上涨区间的左端点（最早时间，区间最低点位置）
            int reboundStartIndex = i + 1;
            decimal reboundLow = prices[reboundStartIndex];
            decimal reboundHigh = prices[reboundEndIndex];
            decimal totalRebound = reboundHigh - reboundLow;

            // 3. 检查整个上涨区间的总涨幅是否超过容忍度
            if (totalRebound > maxReboundTolerance)
            {
                return false;
            }

            // 上涨区间处理完毕，继续往前遍历
            continue;
        }

        // 没有上涨，继续往前推
        i--;
    }

    // 遍历完所有价格都未达到急跌条件
    return false;
}

using System;
using System.Collections.Generic;

public class GoldPriceAnalyzer
{
    #region 内部实体
    private class PullbackInterval
    {
        public decimal High { get; set; }
        public decimal Low { get; set; }
        public int HighIndex { get; set; }
    }

    private class ReboundInterval
    {
        public decimal Low { get; set; }
        public decimal High { get; set; }
        public int LowIndex { get; set; }
    }
    #endregion

    #region IsGoldPriceSharpRise 方法组
    /// <summary>
    /// 判断金价是否急涨（数组版）
    /// </summary>
    /// <param name="prices">金价数组，按时间从旧到新排列</param>
    /// <param name="sharpRiseThreshold">急涨阈值</param>
    /// <param name="maxPullbackTolerance">反向下跌容忍阈值</param>
    /// <returns>是否急涨</returns>
    public static bool IsGoldPriceSharpRise(decimal[] prices, decimal sharpRiseThreshold, decimal maxPullbackTolerance)
    {
        if (prices == null)
            throw new ArgumentNullException("prices", "金价数组不能为null");

        if (prices.Length < 2)
            return false;

        decimal latestPrice = prices[prices.Length - 1];
        int i = prices.Length - 2;
        List<PullbackInterval> pullbacks = new List<PullbackInterval>();

        while (i >= 0)
        {
            decimal riseAmount = latestPrice - prices[i];
            if (riseAmount >= sharpRiseThreshold)
            {
                return FinalValidateSharpRise(pullbacks, maxPullbackTolerance);
            }

            if (prices[i] > prices[i + 1])
            {
                int pullbackEndIndex = i + 1;
                i--;
                while (i >= 0 && prices[i] >= prices[i + 1])
                {
                    i--;
                }

                int pullbackStartIndex = i + 1;
                decimal pullbackHigh = prices[pullbackStartIndex];
                decimal pullbackLow = prices[pullbackEndIndex];
                decimal totalPullback = pullbackHigh - pullbackLow;

                if (totalPullback >= maxPullbackTolerance)
                {
                    return false;
                }

                pullbacks.Add(new PullbackInterval
                {
                    High = pullbackHigh,
                    Low = pullbackLow,
                    HighIndex = pullbackStartIndex
                });

                continue;
            }

            i--;
        }

        return false;
    }

    /// <summary>
    /// 判断金价是否急涨（List版重载）
    /// </summary>
    /// <param name="prices">金价数组，按时间从旧到新排列</param>
    /// <param name="sharpRiseThreshold">急涨阈值</param>
    /// <param name="maxPullbackTolerance">反向下跌容忍阈值</param>
    /// <returns></returns>
    public static bool IsGoldPriceSharpRise(List<decimal> prices, decimal sharpRiseThreshold, decimal maxPullbackTolerance)
    {
        if (prices == null)
            throw new ArgumentNullException("prices", "金价列表不能为null");

        return IsGoldPriceSharpRise(prices.ToArray(), sharpRiseThreshold, maxPullbackTolerance);
    }
    #endregion

    #region IsGoldPriceSharpDrop 方法组
    /// <summary>
    /// 判断金价是否急跌（数组版）
    /// </summary>
    /// <param name="prices">金价数组，按时间从旧到新排列</param>
    /// <param name="sharpDropThreshold">急跌阈值</param>
    /// <param name="maxReboundTolerance">反向上涨容忍阈值</param>
    /// <returns>是否急跌</returns>
    public static bool IsGoldPriceSharpDrop(decimal[] prices, decimal sharpDropThreshold, decimal maxReboundTolerance)
    {
        if (prices == null)
            throw new ArgumentNullException("prices", "金价数组不能为null");

        if (prices.Length < 2)
            return false;

        decimal latestPrice = prices[prices.Length - 1];
        int i = prices.Length - 2;
        List<ReboundInterval> rebounds = new List<ReboundInterval>();

        while (i >= 0)
        {
            decimal dropAmount = prices[i] - latestPrice;
            if (dropAmount >= sharpDropThreshold)
            {
                return FinalValidateSharpDrop(rebounds, maxReboundTolerance);
            }

            if (prices[i] < prices[i + 1])
            {
                int reboundEndIndex = i + 1;
                i--;
                while (i >= 0 && prices[i] <= prices[i + 1])
                {
                    i--;
                }

                int reboundStartIndex = i + 1;
                decimal reboundLow = prices[reboundStartIndex];
                decimal reboundHigh = prices[reboundEndIndex];
                decimal totalRebound = reboundHigh - reboundLow;

                if (totalRebound >= maxReboundTolerance)
                {
                    return false;
                }

                rebounds.Add(new ReboundInterval
                {
                    Low = reboundLow,
                    High = reboundHigh,
                    LowIndex = reboundStartIndex
                });

                continue;
            }

            i--;
        }

        return false;
    }

    /// <summary>
    /// 判断金价是否急跌（List版重载）
    /// </summary>
    /// <param name="prices">金价数组，按时间从旧到新排列</param>
    /// <param name="sharpDropThreshold">急跌阈值</param>
    /// <param name="maxReboundTolerance">反向上涨容忍阈值</param>
    /// <returns></returns>
    public static bool IsGoldPriceSharpDrop(List<decimal> prices, decimal sharpDropThreshold, decimal maxReboundTolerance)
    {
        if (prices == null)
            throw new ArgumentNullException("prices", "金价列表不能为null");

        return IsGoldPriceSharpDrop(prices.ToArray(), sharpDropThreshold, maxReboundTolerance);
    }
    #endregion

    #region 内部验证方法
    /// <summary>
    /// 急涨最终验证逻辑
    /// </summary>
    /// <param name="pullbacks"></param>
    /// <param name="maxTolerance"></param>
    /// <returns></returns>
    private static bool FinalValidateSharpRise(List<PullbackInterval> pullbacks, decimal maxTolerance)
    {
        if (pullbacks.Count == 0)
            return true;

        PullbackInterval maxHighInterval = pullbacks[0];
        foreach (PullbackInterval interval in pullbacks)
        {
            if (interval.High > maxHighInterval.High)
                maxHighInterval = interval;
        }

        decimal minLowAfterMaxHigh = maxHighInterval.Low;
        foreach (PullbackInterval interval in pullbacks)
        {
            if (interval.HighIndex > maxHighInterval.HighIndex)
            {
                if (interval.Low < minLowAfterMaxHigh)
                    minLowAfterMaxHigh = interval.Low;
            }
        }

        decimal totalMaxPullback = maxHighInterval.High - minLowAfterMaxHigh;
        return totalMaxPullback < maxTolerance;
    }

    /// <summary>
    /// 急跌最终验证逻辑（与急涨完全对称）
    /// </summary>
    /// <param name="rebounds"></param>
    /// <param name="maxTolerance"></param>
    /// <returns></returns>
    private static bool FinalValidateSharpDrop(List<ReboundInterval> rebounds, decimal maxTolerance)
    {
        if (rebounds.Count == 0)
            return true;

        ReboundInterval minLowInterval = rebounds[0];
        foreach (ReboundInterval interval in rebounds)
        {
            if (interval.Low < minLowInterval.Low)
                minLowInterval = interval;
        }

        decimal maxHighAfterMinLow = minLowInterval.High;
        foreach (ReboundInterval interval in rebounds)
        {
            if (interval.LowIndex > minLowInterval.LowIndex)
            {
                if (interval.High > maxHighAfterMinLow)
                    maxHighAfterMinLow = interval.High;
            }
        }

        decimal totalMaxRebound = maxHighAfterMinLow - minLowInterval.Low;
        return totalMaxRebound < maxTolerance;
    }
    #endregion
}

// 坑1：全局大try-catch
try
{
    int e = a + b;
    int f = e + 2;
    int g = c + d;
}
catch
{
    Console.WriteLine("计算出错了！");
}

// 坑2：每行一个try-catch
int e, f, g;

try
{
    e = a + b;
}
catch
{
    Console.WriteLine("a+b 出错了！");
}

try
{
    f = e + 2; // e 没赋值成功，这里继续报错
}
catch
{
    Console.WriteLine("e+2 出错了！");
}

try
{
    g = c + d;
}
catch
{
    Console.WriteLine("c+d 出错了！");
}

// 正确的做法
int e, f, g;

// 第一组：有依赖关系的步骤放一起
try
{
    e = a + b;
    f = e + 2;
}
catch
{
    Console.WriteLine("f 值计算出错！");
}

// 第二组：独立无依赖，单独捕获
try
{
    g = c + d;
}
catch
{
    Console.WriteLine("g 值计算出错！");
}