/********************************************************************
 * Name: smk.c
 * Author: rashaudteague
 * Date: 03/09/2013
 * License: GNU GPL <http://www.gnu.org/licenses/>
 * Description: <description>
 ********************************************************************/

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <stdarg.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/fcntl.h>
#include <getopt.h>
#include <limits.h>
#include <time.h>
#include <dirent.h>

char *substr(const char *s, char *buffer, int start, int length) {
    size_t s_len = strlen(s);

    if (!(length > s_len || start > s_len - 1)) {
        if (start < 0) start = s_len + start;
        if (length < 0) {
            start = start + length;
            length *= -1;
        }
        if (!(start == 0 && length == 0)) {
            if (start + length > s_len) length = s_len - start;
            memcpy(buffer, s + start, length);
        }
    } else {
        length = 0;
    }
   
    buffer[length] = '\0';
    return buffer;
}

int strpos(const char *needle, const char *haystack, int offset) {
    int pos = -1;
    int haystack_size = strlen(haystack);
    int needle_size = strlen(needle);
    int i;
    char *search;
    if ((search = (char *) malloc(sizeof(char) * needle_size + 1)) == NULL) {
        fprintf(stderr, "error in malloc in strpos\n");
        exit(EXIT_FAILURE);
    }
    for (i = 0; i < haystack_size; i++) {
        substr(haystack, search, i, needle_size);
       
        if (strcmp(search, needle) == 0) {
            if (offset > 0) {
                i = i + (needle_size - 1);
                offset--;
            } else {
                free(search);
                return i;
            }
        }
    }
    free(search);
    return pos;
}

char *str_replace(const char *find, const char *replace, const char *source, char *buffer) {
    int i = 0, p = 0, c = 0;
    size_t find_len    = strlen(find);
    size_t replace_len = strlen(replace);
    size_t source_len  = strlen(source);
    while ((c = strpos(find, source, i++)) >= 0) {
        strncpy(buffer+strlen(buffer), source+p, c-p);
        strncpy(buffer+strlen(buffer), replace, replace_len);
        p = c + find_len;
    }
    strncpy(buffer+strlen(buffer), source+p, source_len - p);
    buffer[strlen(buffer)] = '\0';
    return buffer;
}

char *strrev(char *str) {
    size_t str_size = strlen(str);
   
    char temp;
    size_t middle = ceil(str_size / 2);
    size_t i;
    for (i = 0; i < middle; i++) {
        temp = str[i];
        str[i] = str[str_size - i - 1];
        str[str_size - i - 1] = temp;
    }
   
    return str;
}

char * strtoupper(char *str) {
    int str_size = (int) strlen(str);
   
    int i = 0;
    for ( ; i < str_size; i++) str[i] = toupper(str[i]);
   
    return str;
}

int copy(const char *source, const char *dest) {
    char c;
    int in, out;
    struct stat fs;
   
    if ((in = open(source, O_RDONLY, 0)) == -1) return 0;
    stat(source, &fs);
   
    if ((out = open(dest, O_WRONLY | O_CREAT, fs.st_mode)) == -1) return 0;

    while (read(in, &c, 1) > 0) write(out, &c, 1);

    close(in); close(out);
   
    return 1;
}

int file_get_contents(const char * filename, char *buffer, int maxlen) {
    FILE *fp;
    if ((fp = fopen(filename, "r")) == NULL) return -1;

    int c, i = 0;

    while ((c = getc(fp)) != EOF && i < maxlen) { buffer[i] = c; i++; }
    buffer[i] = '\0';

    fclose(fp);

    return i;
}

int filesize(const char *name) {
    struct stat fbuf; if (stat(name, &fbuf) == -1) return -1; return fbuf.st_size;
}

int file_exists(const char *name) {
    struct stat fbuf; if (stat(name, &fbuf) == -1) return 0; return 1;
}

void print_usage() {
    printf(
    "Source maker (smk)\n"                                                                                        \
    "options:\n"                                                                                                  \
    "-p, --project make a project, specify the project's name after p option, this will create a new directory\n" \
    "-v, --verbose verbose of the what is going on\n"                                                             \
    "-h, --help prints program information\n\n"                                                                   \
    "examples:\n"                                                                                                 \
    "smk c_code.c\n"                                                                                              \
    "smk -p myproject c_code.c c_code.h\n"                                                                        \
    "smk c_code.c c_code.h\n"                                                                                     \
    "smk script.py && chmod a+x script.py\n"                                                                      \
    "smk script1.sh script2.sh script3.sh && chmod a+x *.sh\n"                                                    \
    "\nCopyright (c) 2009-2013 Maris Labs\n"                                                                      \
    );
}

void open_write_template(FILE *fp, const char *path, const char *data) {
    if ((fp = fopen(path, "w")) == NULL)
        printf("Warning: Could not write file %s\n", path);
    if (data != NULL) fputs(data, fp);
}

int main(int argc, char **argv) {
    int next_option = 0;
    char *short_options = "p:vh";
    const struct option long_options[] = {
        {"project", 1, NULL, 'p'},
        {"help",    0, NULL, 'h'},
        {"verbose", 0, NULL, 'v'},
        {NULL,      0, NULL, 0  }
    };
   
    char verbose = 0;
    char verbose_buffer[LINE_MAX];
    memset(verbose_buffer, 0, LINE_MAX);
   
    char template_buffer[LINE_MAX];
    char content[LINE_MAX];
    char template_path[PATH_MAX];
    char template_path_buffer[LINE_MAX];
    char cwd[PATH_MAX];
    getcwd(cwd, PATH_MAX);
    sprintf(template_path, "%s/.smk", getenv("HOME"));

    struct dirent *dp;
    DIR *dfd;
    struct stat temp_stat;
   
    char var_smk[10] = "/var/smk";
    char var_template[PATH_MAX]; // the name of the template file from /var/smk
    char dest_template[PATH_MAX]; // path/to/userhomedir/.smk/template filename
   
    if (!file_exists(template_path)) {
        printf("Warning: %s does not exist, needed for looking up and loading templates, creating /.smk in ~/.\n", template_path);
        mkdir(template_path, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
       
        if ((dfd = opendir(var_smk)) != NULL) {
            while ((dp = readdir(dfd)) != NULL) {
                if (strcmp(dp->d_name, ".") == 0 || strcmp(dp->d_name, "..") == 0)
                    continue;
                memset(&temp_stat, 0, sizeof(struct stat));
                stat(dp->d_name, &temp_stat);
               
                if (!(temp_stat.st_mode & S_IFDIR)) {
                    sprintf(var_template, "%s/%s", var_smk, dp->d_name);
                    sprintf(dest_template, "%s/%s", template_path, dp->d_name);
                    if (copy(var_template, dest_template)) {
                        chown(dest_template, getuid(), getgid());
                    } else printf("Warning: Could not copy %s to %s\n", var_template, template_path);
                }
            }

            closedir(dfd);
        } else {
            printf("Warning: could not open %s\n", var_smk);   
        }
    }
   
    while (next_option != -1) {
        next_option = getopt_long(argc, argv, short_options, long_options, NULL);
       
        switch (next_option) {
            case 'p':
                sprintf(verbose_buffer, "%s\ncreating project: %s", verbose_buffer, optarg);
               
                sprintf(cwd, "%s/%s", cwd, optarg);
                if (!file_exists(cwd))
                    mkdir(cwd, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
                   
                break;
            case 'v':
                verbose = 1;
                break;
            case 'h':
                print_usage();
                break;
            case '?':
                print_usage();
                exit(EXIT_FAILURE);
                break;
            default:;
        }
    }

    int i, k;
    size_t argv_len;
    char file_ext[8];
    char c_header[NAME_MAX];
    char file_path[NAME_MAX];

    time_t tc; // tc = time capture
    time(&tc);
   
    char date[32];
    strcpy(date, ctime(&tc));
    date[strlen(date) - 1] = '\0';

    FILE *fp;
   
    // create the files
    while (argv[optind] != NULL) {
        sprintf(verbose_buffer, "%s\ncreating source file: %s\n", verbose_buffer, argv[optind]);
       
        sprintf(file_path, "%s/%s", cwd, argv[optind]);
       
        //find and read the template
        memset(file_ext, 0, 8);
        argv_len = strlen(argv[optind]);
        for (i = argv_len - 1, k = 0; i >= 0 && argv[optind][i] != 0x2E; i--, k++)
            file_ext[k] = argv[optind][i];
        strrev(file_ext);
        memset(template_buffer, 0, LINE_MAX);
        sprintf(template_path_buffer, "%s/%s_template", template_path, file_ext);
        sprintf(verbose_buffer, "%s\n\tusing template: %s\n", verbose_buffer, template_path_buffer);
       
        if (file_get_contents(template_path_buffer, template_buffer, LINE_MAX) >= 0) {
            if (strcmp(file_ext, "h") == 0) {
                strtoupper(argv[optind]);
                memset(c_header, 0, NAME_MAX);
                str_replace(".", "_", argv[optind], c_header);
                strcat(c_header, "_");
                strcpy(argv[optind], c_header);
            }
           
            memset(content, 0, LINE_MAX);
            str_replace("$filename", argv[optind], template_buffer, content);
           
            strcpy(template_buffer, content); memset(content, 0, LINE_MAX);
            str_replace("$author", getenv("USER"), template_buffer, content);
           
            strcpy(template_buffer, content); memset(content, 0, LINE_MAX);
            str_replace("$date", date, template_buffer, content);
           
            open_write_template(fp, file_path, content);
        } else {
            open_write_template(fp, file_path, NULL);
            sprintf(verbose_buffer, "%s\tWarning: Could not load template %s_template\n", verbose_buffer, file_ext);
        }
        if (fp != NULL) fclose(fp);
        optind++;
    }

    if (verbose) printf("\n%s\n", verbose_buffer);
   
    return 0;
}