#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <getopt.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

// 定义选项结构体
typedef struct {
    char *f_arg;      // -f 选项的参数
    int r_flag;       // -r 选项的标志
    int d_flag;       // -d 选项的标志
    char *str_arg;    // 最后的字符串参数
} Options;

int flash_flag = 0;
int read_flag = 0;
int dp_flag = 0;
long int display_value = 0;
// 打印使用说明
void print_usage(const char *program_name) {
    printf("Usage: %s [options] <string>\n", program_name);
    printf("Options:\n");
    printf("  -f <arg>    Specify an argument for -f option\n");
    printf("  -r          Enable r option (no argument)\n");
    printf("  -d          Enable d option (no argument)\n");
    printf("  -h          Show this help message\n");
    printf("\nExample:\n");
    printf("  %s -f config.txt -r -d hello\n", program_name);
    printf("  %s -r -f data.txt world\n", program_name);
}

// 解析命令行参数
int parse_arguments(int argc, char *argv[], Options *opts) {
    int opt;
    int ret = 0;
    int f_option_count = 0;  // 统计 -f 出现的次数
    
    // 初始化选项结构体
    memset(opts, 0, sizeof(Options));
    
    // 使用getopt循环解析选项
    while ((opt = getopt(argc, argv, "f:rdh")) != -1) {
        switch (opt) {
            case 'f':
                // -f 选项，必须跟参数
                flash_flag = atoi(optarg);
                opts->f_arg = optarg;
                f_option_count++;
                printf("[DEBUG] -f option with argument: %s\n", optarg);
                break;
                
            case 'r':
                // -r 选项，不跟参数
                read_flag = 1;
                opts->r_flag = 1;
                printf("[DEBUG] -r option enabled\n");
                break;
                
            case 'd':
                // -d 选项，不跟参数
                dp_flag = 1;
                opts->d_flag = 1;
                printf("[DEBUG] -d option enabled\n");
                break;
                
            case 'h':
                // 帮助选项
                print_usage(argv[0]);
                return 0;  // 正常退出
                
            case '?':
                // getopt会自动打印错误信息
                return -1;  // 解析错误
                
            default:
                fprintf(stderr, "Unexpected option: %c\n", opt);
                return -1;
        }
    }
    
    // 检查 -f 选项出现次数（可选，根据需求）
    if (f_option_count > 1) {
        fprintf(stderr, "Error: -f option can only be used once\n");
        return -1;
    }
    
    // 检查是否有额外的参数（最后的字符串）
    if (optind < argc) {
        // 如果有多个剩余参数，取第一个作为字符串，其余的忽略或报错
        if (argc - optind > 1) {
            fprintf(stderr, "Warning: Extra arguments after string will be ignored\n");
        }
        opts->str_arg = argv[optind];
        char *endptr;
        display_value = strtol(opts->str_arg, &endptr, 16);
        if(*endptr != '\0')
        {
            printf("Error: Invalid string argument\n");
            return -1;
        }
        else
        {
            printf("display_value=%lx\n", display_value);
        }

        printf("[DEBUG] String argument: %s\n", opts->str_arg);
    } else {
        // 如果没有提供最后的字符串参数，报错
        fprintf(stderr, "Error: Missing required string argument\n");
        print_usage(argv[0]);
        return -1;
    }
    
    return 1;  // 解析成功
}

// 显示解析结果
void show_results(Options *opts) {
    printf("\n=== Parsing Results ===\n");
    
    if (opts->f_arg) {
        printf("-f option argument: %s\n", opts->f_arg);
    } else {
        printf("-f option not specified\n");
    }
    
    printf("-r option: %s\n", opts->r_flag ? "enabled" : "disabled");
    printf("-d option: %s\n", opts->d_flag ? "enabled" : "disabled");
    
    if (opts->str_arg) {
        printf("String argument: %s\n", opts->str_arg);
    }
    
    printf("======================\n");
}

int main(int argc, char *argv[]) {
    Options opts;
    int ret;
    unsigned int cmd = 0;
    int fd = 0;
    
    printf("Argument Parser Demo\n");
    printf("====================\n");
    printf("Total arguments: %d\n", argc);
    
    // 显示原始参数
    printf("Raw arguments:");
    for (int i = 0; i < argc; i++) {
        printf(" [%d]%s", i, argv[i]);
    }
    printf("\n\n");
    
    // 解析参数
    ret = parse_arguments(argc, argv, &opts);
    
    if (ret == 0) {
        // 帮助信息已显示，正常退出
        return 0;
    } else if (ret < 0) {
        fprintf(stderr, "\nArgument parsing failed!\n");
        return 1;
    }
    
    // 显示解析结果
    show_results(&opts);
    fd = open("/dev/ssegment", O_RDWR);
    if(fd < 0)
    {
        printf("open led device failed\n");
        return -1;
    }
    
    cmd = 0;
    if(dp_flag == 1)
    {
        cmd = cmd | 0x0200;
    }
    if(flash_flag == 1)
    {
        cmd = cmd | 0x8000;
    }

    cmd = cmd | (display_value & 0xff);
    if(read_flag == 1)
    {
        cmd = 0;
        ret = read(fd, &cmd, 4);
        if(ret < 0)
        {
            printf("read led device failed\n");
            return -1;
        }
        printf("read led device success, cmd=%x\n", cmd);
    }
    else
    {
        ret = write(fd, &cmd, 4);
        if(ret < 0)
        {
            printf("write led device failed\n");
            return -1;
        }
    }


    
    return 0;
}