#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <unistd.h>

char *partLower    = "abcdefghijklmnopqrstuvwxyz";
char *partDigit    = "0123456789";
char *partHex      = "ABCDEF";
char *partUpper    = "GHIJLKMNOPQRSTUVWXWY";
char *partPunct    = "!@#$%^&()-=+.,~`;/\\?*:|\"<>_";

char alphabet[256];

size_t num[256];
size_t scale_of_notation[256];
char *alphabet_num[256];
size_t len;
size_t min;
size_t max;
char file_name_to_save[256];
char prefix[256];
char suffix[256];


size_t stop = 0;

/////////////////////////////////////
void sig_handler(int signo)
{
    if (signo == SIGINT)
    {
        fprintf(stderr,"received signal\n");
        stop = 1;
    }
}
/////////////////////////////////////
void load()
{
    FILE * pFile = fopen (file_name_to_save,"r+");

    if (pFile!=NULL)
    {
        fscanf(pFile, "%d,%d,%d\r", &min, &max, &len);
        fscanf(pFile, "%s\r%s\r%s\r", file_name_to_save, prefix, suffix);
        if( strcmp( prefix, "(null)") == 0) prefix[0]=0;
        if( strcmp( suffix, "(null)") == 0) suffix[0]=0;

        for(size_t i=0; i<max+1; i++)
            fscanf(pFile, "%d,%d,", &num[i], &scale_of_notation[i]);
        fscanf(pFile, "\r");

        for(size_t i=0; i<max+1; i++)
        {
            alphabet_num[i] = calloc(256, 1);
            for(size_t k=0; k<scale_of_notation[i]; k++)
                fscanf(pFile, "%c\r", &alphabet_num[i][k]);
            fscanf(pFile, "\r");
        }

        char str[256]; str[0]=0;
        fscanf (pFile, "\r%s\r", &str[0]);
        if(strcmp( str, "m_Sla") != 0)
        {
            fprintf(stderr,"\nBad file.\n");
            exit(-10);
        }

        fclose (pFile);
    }
    else
    {
        fprintf(stderr,"\nCan't open file.\n");
    }
}
/////////////////////////////////////
void save()
{
    FILE * pFile = fopen (file_name_to_save,"w+");

    if (pFile!=NULL)
    {
        fprintf (pFile, "%d,%d,%d\r", min, max, len);
        if(!prefix[0])strcpy(prefix,"(null)");
        if(!suffix[0])strcpy(suffix,"(null)");
        fprintf (pFile, "%s\r%s\r%s\r", file_name_to_save, prefix, suffix);

        for(size_t i=0; i<max+1; i++)
            fprintf (pFile, "%d,%d,", num[i],scale_of_notation[i]);
        fprintf(pFile, "\r");

        for(size_t i=0; i<max+1; i++)
        {
            for(size_t k=0; k<scale_of_notation[i]; k++)
                fprintf (pFile, "%c\r", alphabet_num[i][k]);
            fprintf(pFile, "\r");
        }
        fprintf (pFile, "\rm_Sla\r");

        fclose (pFile);
    }
    else
    {
        fprintf(stderr,"\nCan't open file.\n");
    }
}
/////////////////////////////////////
void work()
{
    char *str = malloc(1024*1024);
    char *ptr_str = str;

    while(len <= max)
    {
        //вывод num
        if(prefix[0])
        {
            char *ptr = prefix;
            while(*ptr)
            {
                *ptr_str++ = *ptr++;
            }
        }

        size_t i = 0;
        while(num[i])
        {
            *ptr_str = alphabet_num[i][num[i] - 1];
            i++;
            ptr_str++;
        }

        if(suffix[0])
        {
            char *ptr = suffix;
            while(*ptr)
            {
                *ptr_str++ = *ptr++;
            }
        }
        *ptr_str++ = '\n';

        if(ptr_str - str > 1024*1024 - 256)
        {
            *ptr_str = 0;
            puts(str);
            ptr_str = str;
        }

        if(stop)
        {
            save();
            break;
        }

        // увеличиваем num на 1
        i = 0;
        size_t carry = 0;
        do
        {
            num[i]++;
            if(num[i] > scale_of_notation[i])
            {
                num[i] = 1;
                carry = 1;
            }
            else
            {
                carry = 0;
            }

            i++;
        }
        while(carry);
        if(i > len) len=i;
    }

    *ptr_str = 0;
    puts(str);
    free(str);
}
/////////////////////////////////////
void run( char *alphabet)
{
    // инициализация
    if(!file_name_to_save[0])
        strcpy(file_name_to_save,"pwdgen.sav");

    len = min;
    for(size_t i=0; i < min; i++)
        num[i] = 1;

    for(size_t i=0; i <= max; i++)
    {
        alphabet_num[i]=alphabet;
        scale_of_notation[i]=strlen(alphabet);
    }

    work();
}/////////////////////////////////////

struct option_result
{
    size_t code;
    char *param;
};

struct option
{
    char *opt;
    size_t code;
};

struct option options[] =
{
    {"lower",1},
    {"punct",2},
    {"upper",3},
    {"xdigit",4},
    {"digit",5},
    {"\0x00",0}
};

struct option options2[] =
{
    {"prefix=",1001},
    {"suffix=",1002},
    {"save=",1003},
    {"\0x00",0}
};

/////////////////////////////////////
struct option_result find_option(char *option)
{
    struct option_result result = {0,0};

    for(size_t i=0; *options[i].opt; i++)
        if (strcmp( option, options[i].opt) == 0)
        {
            result.code = options[i].code;
            options[i].code = 0;
            return result;
        }

    for(size_t i=0; *options2[i].opt; i++)
        if (strstr( option, options2[i].opt) != NULL)
        {
            result.param = strstr( option, options2[i].opt) + strlen(options2[i].opt);
            result.code = options2[i].code;
            options2[i].code = 0;
            return result;
        }

    return result;
}
/////////////////////////////////////
int main(int argc,char **arg, char **env)
{
    if (signal(SIGINT, sig_handler) == SIG_ERR)
        fprintf(stderr,"\ncan't catch SIGINT\n");

    if (argc > 1 && strstr( arg[1], "continue")  != NULL)
    {
        fprintf(stderr,"Continue.\n");

        if( *(arg[1] + strlen("continue")) )
            strcpy(file_name_to_save, arg[1] + strlen("continue") + 1);
        else
            strcpy(file_name_to_save,"pwdgen.sav");

        fprintf(stderr,"Read: %s\n", file_name_to_save);

        load();
        work();
        return 0;
    }
    if (argc < 3)
    {
        fprintf(stderr,"\nPassword Generation 2.0 (c) m_Sla and SQL.RU. Written in 'C' :)\n");
        fprintf(stderr,"Special thnx to: Mayton, Dima T.\n");
        fprintf(stderr,"\nUsage: pwdgen [n | continue=] [m] [options..] \n");
        fprintf(stderr,"\n       continue=  - Filename");
        fprintf(stderr,"\nWhere: options:\n");
        fprintf(stderr,"\n       lower      - Lowercase alphabetic characters [a..z]");
        fprintf(stderr,"\n       punct      - Punctuation characters [,!?..]");
        fprintf(stderr,"\n       upper      - Uppercase alphabetic characters [A..Z]");
        fprintf(stderr,"\n       xdigit     - Hexidecimal characters");
        fprintf(stderr,"\n       digit      - Numeric digits [0..9]");
        fprintf(stderr,"\n       prefix=    - Various text prefix in begin of password phraze like 'Passw_'");
		fprintf(stderr,"\n       suffix=    - Various text suffix");
		fprintf(stderr,"\n       save=      - Filename");
        fprintf(stderr,"\n");
        return -1;
    }
    else
    {
        min = atoi(arg[1]);
        max = atoi(arg[2]);
        if( min > 255) min=255;
        if( max > 255) max=255;

        if(max < min)
        {
            fprintf(stderr,"\n[m] cannot be less than [n]!\n");
            return -3;
        }

        if (argc==3)
        {
            strcat(alphabet, partLower);
            run( alphabet );
            return 0;
        }
        else
        {
            size_t i = 3;
            while(i<argc)
            {
                struct option_result result=find_option(arg[i]);
                switch(result.code)
                {
                case 1: // lower
                    strcat(alphabet,partLower);
                    break;
                case 2: // punct
                    strcat(alphabet,partPunct);
                    break;
                case 3: // upper
                    strcat(alphabet,partHex);
                    strcat(alphabet,partUpper);
                    break;
                case 4: // xdigit
                    strcat(alphabet,partDigit);
                    strcat(alphabet,partHex);
                    break;
                case 5: // digit
                    strcat(alphabet,partDigit);
                    break;

                case 1003: // save=
                    if(strlen(result.param))
                        strcpy(file_name_to_save,result.param);
                    break;
                case 1001: // prefix=
                    if(strlen(result.param))
                        strcpy(prefix,result.param);
                    break;
                case 1002: // suffix=
                    if(strlen(result.param))
                        strcpy(suffix,result.param);
                    break;
                }
                i++;
            }

            if(!strlen(alphabet)) strcat(alphabet, partLower);
            run( alphabet );
        }
    }
    return 0;
}
/////////////////////////////////////