/*
 * Copyright 2008, Haiku.
 * Distributed under the terms of the MIT license.
 *
 * Authors:
 *              Michael Pfeiffer <laplace@users.sourceforge.net>
 */

#include "PPDParser.h"

#include "AutoDelete.h"

#include <stdio.h>
#include <stdlib.h>

// #define VERBOSE 1 

struct Keyword {
        const char* name;
        const char* since;
        int major;
        int minor;
        bool found;
};

static const Keyword gRequiredKeywords[] = {
        {"DefaultImageableArea", NULL},
        {"DefaultPageRegion", NULL},
        {"DefaultPageSize", NULL},
        {"DefaultPaperDimension", NULL},
        // sometimes missing
        // {"FileVersion", NULL},
        // 
        // {"FormatVersion", NULL},
        {"ImageableArea", NULL},
        // "since" is not specified in standard!
        {"LanguageEncoding", "4.3"},
        {"LanguageVersion", NULL},
        {"Manufacturer", "4.3"},
        {"ModelName", NULL},
        {"NickName", NULL},
        {"PageRegion", NULL},
        {"PageSize", NULL},
        {"PaperDimension", NULL},
        {"PCFileName", NULL},
        {"PPD-Adobe", NULL},
        {"Product", NULL},
        {"PSVersion", NULL},
        // sometimes missing
        // {"ShortNickName", "4.3"},
};

// e.g. *PPD.Adobe: "4.3"
const char* kPPDAdobe = "PPD-Adobe";

#define NUMBER_OF_REQUIRED_KEYWORDS (int)(sizeof(gRequiredKeywords) / sizeof(struct Keyword))

class RequiredKeywords
{
private:
        Keyword fKeywords[NUMBER_OF_REQUIRED_KEYWORDS];
        bool    fGotVersion;
        int     fMajorVersion;
        int     fMinorVersion;
        
        void ExtractVersion(int& major, int& minor, const char* version);
        bool IsVersionRequired(Keyword* keyword);

public:
        RequiredKeywords();
        bool IsRequired(Statement* statement);
        bool IsComplete();
        void AppendMissing(BString* string);
};

RequiredKeywords::RequiredKeywords()
        : fGotVersion(false)
{
        for (int i = 0; i < NUMBER_OF_REQUIRED_KEYWORDS; i ++) {
                fKeywords[i] = gRequiredKeywords[i];
                fKeywords[i].found = false;
                const char* since = fKeywords[i].since;
                if (since != NULL) {
                        ExtractVersion(fKeywords[i].major, fKeywords[i].minor, since);
                }
        }
}

void RequiredKeywords::ExtractVersion(int& major, int& minor, const char* version)
{
        major = atoi(version);
        minor = 0;
        version = strchr(version, '.');
        if (version != NULL) {
                version ++;
                minor = atoi(version);
        }
}

bool RequiredKeywords::IsVersionRequired(Keyword* keyword)
{
        if (keyword->since == NULL) return true;
        // be conservative if version is missing
        if (!fGotVersion) return true;
        // keyword is not required if file version < since
        if (fMajorVersion < keyword->major) return false;
        if (fMajorVersion == keyword->major &&
                fMinorVersion < keyword->minor) return false;
        return true;
}

bool RequiredKeywords::IsRequired(Statement* statement)
{
        const char* keyword = statement->GetKeyword()->String();

        if (!fGotVersion && strcmp(kPPDAdobe, keyword) == 0 && 
                statement->GetValue() != NULL) {
                Value* value = statement->GetValue();
                BString* string = value->GetValue();
                fGotVersion = true;
                ExtractVersion(fMajorVersion, fMinorVersion, string->String());
        }

        BString defaultKeyword;
        if (statement->GetType() == Statement::kDefault) {
                defaultKeyword << "Default" << keyword;
                keyword = defaultKeyword.String();
        }
        
        for (int i = 0; i < NUMBER_OF_REQUIRED_KEYWORDS; i ++) {
                const char* name = fKeywords[i].name;
                if (strcmp(name, keyword) == 0) {
                        fKeywords[i].found = true;
                        return true;
                }
        }
        
        return false;
}

bool RequiredKeywords::IsComplete()
{
        for (int i = 0; i < NUMBER_OF_REQUIRED_KEYWORDS; i ++) {
                if (!fKeywords[i].found && IsVersionRequired(&fKeywords[i])) {
                        return false;
                }
        }
        return true;
}

void RequiredKeywords::AppendMissing(BString* string)
{
        for (int i = 0; i < NUMBER_OF_REQUIRED_KEYWORDS; i ++) {
                if (!fKeywords[i].found && IsVersionRequired(&fKeywords[i])) {
                        *string << "Keyword " << fKeywords[i].name;
                        if (fKeywords[i].since != NULL) {
                                *string << fKeywords[i].major << ". " << fKeywords[i].minor 
                                << " < " <<
                                fMajorVersion << "." << fMinorVersion << " ";
                        }
                        *string << " is missing\n";
                }
        }       
}

// Constants

static const char* kEndStatement = "End";

// Implementation

PPDParser::PPDParser(const char* file)
        : Parser(file)
        , fStack(false)
        , fRequiredKeywords(new RequiredKeywords)
{
}

PPDParser::~PPDParser()
{
        delete fRequiredKeywords;
}

void PPDParser::Push(Statement* statement)
{
        fStack.Add(statement);
}

Statement* PPDParser::Top()
{
        if (fStack.Size() > 0) {
                return fStack.StatementAt(fStack.Size()-1);
        }
        return NULL;
}

void PPDParser::Pop()
{
        fStack.Remove(Top());
}

void PPDParser::AddStatement(Statement* statement)
{
        fRequiredKeywords->IsRequired(statement);
        
        Statement* top = Top();
        if (top != NULL) {
                top->AddChild(statement);
        } else {
                fPPD->Add(statement);
        }
}

bool PPDParser::IsValidOpenStatement(GroupStatement* statement)
{
        if (statement->GetGroupName() == NULL) {
                Error("Missing group ID in open statement");
                return false;
        }
        return true;
}

bool PPDParser::IsValidCloseStatement(GroupStatement* statement)
{
        if (statement->GetGroupName() == NULL) {
                Error("Missing option in close statement");
                return false;
        }

        if (Top() == NULL) {
                Error("Close statement without an open statement");
                return false;
        }               
        
        GroupStatement openStatement(Top());
                
        // check if corresponding Open* is on top of stack
        BString open = openStatement.GetKeyword();
        open.RemoveFirst("Open");
        BString close = statement->GetKeyword();
        close.RemoveFirst("Close");

        if (open != close) {
                Error("Close statement has no corresponding open statement");
#ifdef VERBOSE
                printf("********* OPEN ************\n");
                openStatement.GetStatement()->Print();
                printf("********* CLOSE ***********\n");
                statement->GetStatement()->Print();
#endif
                return false;
        }

        BString openValue(openStatement.GetGroupName());
        BString closeValue(statement->GetGroupName());

        const char* whiteSpaces = " \t";
        openValue.RemoveSet(whiteSpaces);
        closeValue.RemoveSet(whiteSpaces);

        if (openValue != closeValue) {
                BString message("Open name does not match close name ");
                message << openValue << " != " << closeValue << "\n";
                Warning(message.String());
        }

        return true;
}               

bool PPDParser::ParseStatement(Statement* _statement)
{
        AutoDelete<Statement> statement(_statement);
        
        if (_statement->GetKeyword() == NULL) {
                Error("Keyword missing");
                return false;
        }
        
        if (_statement->GetOption() != NULL && 
                _statement->GetOption()->GetValue() == NULL) {
                // The parser should not provide an option without a value
                Error("Option has no value");
                return false;
        }
        
        if (_statement->GetValue() != NULL && 
                _statement->GetValue()->GetValue() == NULL) {
                // The parser should not provide a value without a value
                Error("Value has no value");
                return false;
        }
        
        const char* keyword = statement.Get()->GetKeyword()->String();
        if (strcmp(keyword, kEndStatement) == 0) {
                // End is ignored
                return true;
        }
        
        GroupStatement group(statement.Get());
        if (group.IsOpenGroup()) {
                
                if (!IsValidOpenStatement(&group)) {
                        return false;
                }
                // Add() has to be infront of Push()!
                AddStatement(statement.Release());
                // begin of nested statement
                Push(statement.Get());
                return true;
        }

        if (group.IsCloseGroup()) {

                // end of nested statement
                if (!IsValidCloseStatement(&group)) {
                        return false;
                }
        
                Pop();
                // The closing statement is not stored
                return true;
        }
        
        AddStatement(statement.Release());
        return true;
}

bool PPDParser::ParseStatements()
{
        Statement* statement;
        while ((statement = Parser::Parse()) != NULL) {
#ifdef VERBOSE
                statement->Print(); fflush(stdout);
#endif
                if (!ParseStatement(statement)) {
                        return false;
                }
                
                if (!fParseAll && fRequiredKeywords->IsComplete()) {
                        break;
                }
        }
        
        if (HasError()) {
                return false;
        }
        
        if (Top() != NULL) {
                BString error("Missing close statement for:\n");
                do {
                        error << " * " << 
                                Top()->GetKeywordString() << " " << 
                                Top()->GetOptionString() << "\n";
                        Pop();
                } while (Top() != NULL);
                Error(error.String());
                return false;
        }
        return true;
}

PPD* PPDParser::Parse(bool all)
{
        fParseAll = all;
        
        if (InitCheck() != B_OK) return NULL;
        
        fPPD = new PPD();

        ParseStatements();
        
        if (!HasError() && !fRequiredKeywords->IsComplete()) {
                BString string;
                fRequiredKeywords->AppendMissing(&string);
                Error(string.String());
        }
                
        if (HasError()) {
                delete fPPD; fPPD = NULL;
                return NULL;
        }
        
        return fPPD;
}

PPD* PPDParser::ParseAll()
{
        return Parse(true);
}

PPD* PPDParser::ParseHeader()
{
        return Parse(false);
}