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; // 子节点列表（仅目录有效）
        }
    }
}

/// <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 值计算出错！");
}

List<string> lst = new List<string>() { "www", "mzwu", "com" };
Console.WriteLine(lst[0]);

Dictionary<string, string> dit = new Dictionary<string, string>() { { "name", "Jack" }, { "age", "30" } };
Console.WriteLine(dit["name"]);

<img src="data:image/png;base64,转换的Base64字符串"/>

<audio src="data:audio/wav;base64,转换的Base64字符串 />

ImageHelper.Compress(@"C:\mzwu_com.jpg", @"C:\mzwu_net.jpg", 50L);