/*

 *=============================================================================

 *  Main program for DATCOM-MODELER

 *

 *  Copyright (C) 2009  Anders Gidenstam (anders(at)gidenstam.org)

 *  Copyright (C) 2009  Ronald Jensen    (ron(at)jentronics.com)

 *  http://www.gidenstam.org

 *  http://www.jentronics.com

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; either version 3 of the License, or

 *  (at your option) any later version.

 *

 *  This program is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this program; if not, write to the Free Software

 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *=============================================================================

 */

#include <unistd.h>

#include <stdio.h>

#include <stdlib.h>

#include "datcom-parser.h"

#include "modeler_proto.h"

int verbose=1; /* External to all other modules */

/* Verbose Levels:

 *

 * 0. Quiet: No output on stderr

 * 1. Default: Print errors

 * 2. Chatty: Print interesting trivia, warnings

 * 3. Verbose: Print everything

 *

 */

int dofoils(DATCOM_AIRFOIL *datcomfoil, struct AIRFOIL *foil, char * defaultfoil);

void PrintAC(struct AIRCRAFT *ac)

{

    return;

}

void Usage(char *name)

{

    fprintf(stderr, "Usage: %s [-n b|e|f|h|v|w] [-v] [-q] [-Q] [-o ac-file] datcom-file\n", name);

}

int main(int argc, char *argv[])

{

    AIRCRAFT ac;

/* We read these on the command line */

    int wing=1;

    int htail=1;

    int vtail=1;

    int vfin=1;

    int body=1;

    int engines=1;

    int opt;

    int quads=0;

    FILE *ofp = stdout;

    char *outputfile=NULL;

/* internal variables */

    int objects = 0;

    int propellers = 0;

    int shiny = 0;

    struct AIRFOIL wingfoil;

    struct AIRFOIL htailfoil;

    struct AIRFOIL vtailfoil;

    struct AIRFOIL vfinfoil;

    while ((opt = getopt(argc, argv, "n:o:qvQ")) != -1)

    {

        switch (opt)

        {

            case 'n':

                switch(optarg[0])

                {

                    case 'b':

                        body=0;

                        break;

                    case 'e':

                        engines = 0;

                        break;

                    case 'f':

                        vfin = 0;

                        break;

                    case 'h':

                        htail=0;

                        break;

                    case 'v':

                        vtail=0;

                        break;

                    case 'w':

                        wing=0;

                        break;

                    default:

                        Usage(argv[0]);

                        exit(EXIT_FAILURE);

                }

                break;

            case 'o':

                outputfile=optarg;

                break;

            case 'v':

                verbose++;

                break;

            case 'q':

                verbose = 0;

                break;

            case 'Q':

                quads=1;

                break;

            default: /* '?' */

                Usage(argv[0]);

                exit(EXIT_FAILURE);

        }

    }

//  fprintf(stderr, "verbose=%d; optind=%d\n", verbose, optind);

    if (optind >= argc) {

        Usage(argv[0]);

        exit(EXIT_FAILURE);

    }

    ReadDatcom(argv[optind], &ac);

/* ReadDatcom will exit() on error so don't create the output file until after it is called */

    if(outputfile)

    {

        fprintf(stderr, "Creating file: %s\n",  outputfile);

        if( ( ofp = fopen(outputfile, "w")) == NULL)

        {

            fprintf(stderr,"Unable to open %s for writing\n", outputfile);

            exit(EXIT_FAILURE);

        }

    }

    PrintAC(&ac);

/* Process wingfoil */

    if (wing) wing = ac.wing.CHRDR > 0. ? 1 : 0; // only render if root chord exists

    if (wing) wing = dofoils(&ac.wingfoil, &wingfoil, "NACA-W-4-2414");

    if (wing) objects += 2;

/* Process htailfoil */

    if (htail) htail = ac.htail.CHRDR > 0. ? 1 : 0; // only render if root chord exists

    if (htail) htail =  dofoils(&ac.htailfoil, &htailfoil, "NACA-H-4-0014");

    if (htail) objects += 2;

/* Process vtailfoil */

    if (vtail) vtail = ac.vtail.CHRDR > 0. ? 1 : 0; // only render if root chord exists

        if (vtail) vtail =  dofoils(&ac.vtailfoil, &vtailfoil, "NACA-V-4-0012");

    if (vtail) objects += 1;

//* Process vfinfoil */

    if (vfin) vfin = ac.vfin.CHRDR > 0. ? 1 : 0; // only render if root chord exists

        if (vfin) vfin =  dofoils(&ac.vfinfoil, &vfinfoil, "NACA-F-4-0012");

    if (vfin) objects += 1;

/* Process Body */

    if (body) body=ac.body.NX > 0. ? 1 : 0;

    if (body) objects +=1;

/* Process Engines */

    if (engines)

    {

        propellers=ac.propwr.NENGSP;

        objects += propellers;

    }

      if(ac.optins.ROUGFC == 0.0) shiny=65;

      else shiny = GetShine(ac.optins.ROUGFC);

      InitAC(ofp, objects, shiny);

      if (wing) WriteWing(ofp, &ac.wing, &wingfoil, "Wing", ac.synths.XW, ac.synths.ZW, quads);

      if (htail) WriteWing(ofp, &ac.htail, &htailfoil, "H-Tail", ac.synths.XH, ac.synths.ZH, quads);

      if (vtail) WriteFin(ofp, &ac.vtail, &vtailfoil, "V-Tail", ac.synths.XV, ac.synths.ZV, 1, quads);

      if (vfin) WriteFin(ofp, &ac.vfin, &vfinfoil, "V-Fin", ac.synths.XVF, ac.synths.ZVF, ac.synths.VERTUP, quads);

      if (body) WriteBody(ofp, &ac.body, &ac.synths, quads);

      if (propellers) WritePropellers(ofp, &ac.propwr);

    return(0);

}

int dofoils(DATCOM_AIRFOIL *datcomfoil, struct AIRFOIL *foil, char * defaultfoil)

{

        if (datcomfoil->NPTS && datcomfoil->YUPPER && datcomfoil->YLOWER)

                DatcomFoil(datcomfoil, foil);

        else if(datcomfoil->NACA_DESCR)

    {

              NacaFoil(datcomfoil->NACA_DESCR, foil, 20);

              foil->COUNT--;

    }

    else if(defaultfoil)

    {

        NacaFoil(defaultfoil, foil, 20);

        foil->COUNT--;

    }

        else return(0);

    return(1);

}