
//  ------------------------------------------------------------------
//  GoldED+
//  Copyright (C) 1990-1999 Odinn Sorensen
//  Copyright (C) 1999-2000 Alexander S. Aganichev
//  ------------------------------------------------------------------
//  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 2 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
//  ------------------------------------------------------------------
//  $Id$
//  ------------------------------------------------------------------
//  Configuration functions, part 1.
//  ------------------------------------------------------------------

#include <golded.h>
#include <gcprot.h>


//  ------------------------------------------------------------------

extern char* val;


//  ------------------------------------------------------------------

void CfgAddress()
{
    CfgAddress(val);
}
void CfgAddress(char* v)
{
    if (not strblank(v))
    {
        if (veryverbose)
            STD_PRINTNL("  CfgAddress(" << v << ")");

        gaka aka;
        aka.domain[0] = NUL;
        aka.pointnet = 0;

        char* ptr = strchr(v, ',');
        if(ptr)
        {
            aka.pointnet = atow(ptr+1);
            *ptr = NUL;
        }
        if(not CFG->aka.empty())
        {
            aka.addr = CFG->aka[0].addr;
            strcpy(aka.domain, CFG->aka[0].domain);
        }
        aka.addr.set(v, aka.domain);

        if(cfgingroup)
            CFG->grp.AddItm(GRP_AKA, &aka, sizeof(gaka));

        int gotaka = GetAkaNo(aka.addr);
        if(gotaka == -1)
            CFG->aka.push_back(aka);
    }
}

//  ------------------------------------------------------------------

void CfgAddressbookadd()
{

    CFG->addressbookadd = GetYesno(val);
}

//  ------------------------------------------------------------------

void CfgAddresslookupfirst()
{

    if(strieql(val, "MSGID"))
        CFG->addresslookupfirst = YES;
    else
        CFG->addresslookupfirst = NO;
}

//  ------------------------------------------------------------------

void CfgAddressmacro(char* v)
{
    val = v;
    CfgAddressmacro();
}
void CfgAddressmacro()
{

    AddrMacro tmp;
    tmp.attr.reset();
    int subjwasquoted = NO;
    char* ptr = val;
    char* ptr2 = strchr(ptr, ',');                                 //  macro^,name,address,subj,attribs
    if(ptr2)
    {
        // Got macroname
        *ptr2++ = NUL;
        strxcpy(tmp.macro, ptr, 20);
        ptr = strskip_wht(ptr2);
        ptr2 = strchr(ptr, ',');                                    //  macro,name^,address,subj,attribs
        if(ptr2)
        {
            // Got real name
            *ptr2++ = NUL;
            strxcpy(tmp.name, ptr, sizeof(IAdr));
            ptr = strskip_wht(ptr2);
            ptr2 = strchr(ptr, ',');                                  //  macro,name,address^,subj,attribs
            if(ptr2)
                *ptr2++ = NUL;
            // Got address
            if(not CFG->aka.empty())
                tmp.addr = CFG->aka[0].addr;
            tmp.addr.set(ptr);
            if(ptr2)
            {
                // Got subject
                ptr = strskip_wht(ptr2);
                if((*ptr == '\"') or (*ptr == '\''))
                {
                    ptr2 = strchr(ptr+1, *ptr);
                    if(ptr2)
                    {
                        subjwasquoted = YES;
                        *ptr2++ = NUL;
                        ptr++;
                    }
                }
                strxcpy(tmp.subj, ptr, sizeof(Subj));

                // Got quoted subj, so look for attribs
                if(subjwasquoted)
                {
                    ptr2 = strchr(ptr2, ',');                             //  macro,name,address,subj^,attribs
                    if(ptr2)
                        GetAttribstr(&tmp.attr, ptr2+1);
                }
            }
            else
                tmp.subj[0] = NUL;
            CFG->addressmacro.push_back(tmp);
        }
    }
}

//  ------------------------------------------------------------------

void CfgAdeptxbbspath(const char *path, bool force)
{

    if (force or strblank(CFG->adeptxbbspath))
        MapPath(PathCopy(CFG->adeptxbbspath, path));
}

void CfgAdeptxbbspath()
{

    CfgAdeptxbbspath(val, true);
}

//  ------------------------------------------------------------------

void CfgAdeptxbbsuserno()
{

    CFG->adeptxbbsuserno = atoi(val);
}

//  ------------------------------------------------------------------

void CfgAkamatch()
{

    char* key;
    getkeyval(&key, &val);

    AkaMatchG akamatchg;
    akamatchg.mask.set_all(GFTN_ALL);
    akamatchg.mask.set(key);
    akamatchg.aka.reset(val);
    CFG->akamatch.push_back(akamatchg);
}

//  ------------------------------------------------------------------

void CfgAkamatchfromto()
{
    CFG->akamatchfromto = GetYesno(val);
}

//  ------------------------------------------------------------------

void CfgAkamatching()
{

    if(cfgingroup)
    {
        bool flag = make_bool(GetYesno(val));
        CFG->grp.AddItm(GRP_AKAMATCHING, flag);
    }
}

//  ------------------------------------------------------------------

void CfgAkamatchmanually()
{
    CFG->akamatchmanually = make_bool(GetYesno(val));
}

//  ------------------------------------------------------------------

void CfgArea()
{

    AL.GetArea(val);
}

//  ------------------------------------------------------------------

void CfgAreaautoid()
{

    if(striinc("VERBOSE", val))
        CFG->areaautoid = AUTOID_VERBOSE;
    else if(striinc("SHORT", val))
        CFG->areaautoid = AUTOID_SHORT;
    else if(striinc("LONG", val))
        CFG->areaautoid = AUTOID_LONG;
}

//  ------------------------------------------------------------------

void CfgAreacfmreplyto()
{

    strxcpy(CFG->areacfmreplyto, val, sizeof(Echo));
}

//  ------------------------------------------------------------------

void CfgAreacopydirect()
{

    bool flag = make_bool(GetYesno(val));
    if(cfgingroup)
        CFG->grp.AddItm(GRP_AREACOPYDIRECT, flag);
    else
        CFG->areacopydirect = flag;
}

//  ------------------------------------------------------------------

void CfgAreacopyto()
{

    Echo buf;
    strxcpy(buf, val, sizeof(buf));
    if(cfgingroup)
        CFG->grp.AddItm(GRP_AREACOPYTO, buf, strlen(buf)+1);
    else
        strcpy(CFG->areacopyto, buf);
}

//  ------------------------------------------------------------------

void CfgAreacopyaddid()
{

    bool flag = make_bool(GetYesno(val));
    if(cfgingroup)
        CFG->grp.AddItm(GRP_AREACOPYADDID, flag);
    else
        CFG->areacopyaddid = flag;
}

//  ------------------------------------------------------------------

void CfgAreadef()
{

    AL.GetAreaDef(val);
}

//  ------------------------------------------------------------------

void CfgAreadesc()
{

    AL.GetAreaDesc(val);
}

//  ------------------------------------------------------------------

void CfgAreaexcl()
{

    tokenize(CFG->areaexcl, val);
}


//  ------------------------------------------------------------------

void CfgAreaforwarddirect()
{

    bool flag = make_bool(GetYesno(val));
    if(cfgingroup)
        CFG->grp.AddItm(GRP_AREAFORWARDDIRECT, flag);
    else
        CFG->areaforwarddirect = flag;
}

//  ------------------------------------------------------------------

void CfgAreafreqdirect()
{

    bool flag = make_bool(GetYesno(val));
    if(cfgingroup)
        CFG->grp.AddItm(GRP_AREAFREQDIRECT, flag);
    else
        CFG->areafreqdirect = flag;
}

//  ------------------------------------------------------------------

void CfgAreafreqto()
{

    Echo buf;
    strxcpy(buf, val, sizeof(buf));
    if(cfgingroup)
        CFG->grp.AddItm(GRP_AREAFREQTO, buf, strlen(buf)+1);
    else
        strcpy(CFG->areafreqto, buf);
}

//  ------------------------------------------------------------------

void CfgAreaincl()
{

    tokenize(CFG->areaincl, val);
}

//  ------------------------------------------------------------------

void CfgAreaisemail()
{

    tokenize(CFG->areaisemail, val);
}

//  ------------------------------------------------------------------

void CfgAreaisnews()
{

    tokenize(CFG->areaisnews, val);
}

//  ------------------------------------------------------------------

void CfgArealistechomax()
{

    CFG->arealistechomax = atoi(val);
}

//  ------------------------------------------------------------------

void CfgArealistformat()
{

    strxcpy(CFG->arealistformat, StripQuotes(val), sizeof(CFG->arealistformat));
}


//  ------------------------------------------------------------------

void CfgArealistgrouporder()
{

    strxcpy(CFG->arealistgrouporder, StripQuotes(val), sizeof(CFG->arealistgrouporder));
}


//  ------------------------------------------------------------------

void CfgArealistscan()
{

    char* _key;
    getkeyval(&_key, &val);
    AL.ListScan.Add(std::pair<std::string, std::string>(StripQuotes(_key), val));
}

//  ------------------------------------------------------------------

void CfgArealistsort()
{

    strxcpy(CFG->arealistsort, val, sizeof(CFG->arealistsort));
}

//  ------------------------------------------------------------------

void CfgArealisttype()
{

    if(strieql(val, "New"))
        CFG->arealisttype = AL_TOTNEW;
    else if(strieql(val, "Last"))
        CFG->arealisttype = AL_TOTLST;
}

//  ------------------------------------------------------------------

void CfgAreapath()
{

    MapPath(PathCopy(CFG->areapath, val));
}

//  ------------------------------------------------------------------

void CfgAreapmscan()
{

    tokenize(CFG->areapmscan, val);
}

//  ------------------------------------------------------------------

void CfgAreapmscanexcl()
{

    tokenize(CFG->areapmscanexcl, val);
}

//  ------------------------------------------------------------------

void CfgAreapmscanincl()
{

    tokenize(CFG->areapmscanincl, val);
}

//  ------------------------------------------------------------------

void CfgAreareadonly()
{

    if(strieql(val, "Soft"))
        CFG->areareadonly = READONLY_SOFT;
    else if(strieql(val, "Hard"))
        CFG->areareadonly = READONLY_HARD;
}

//  ------------------------------------------------------------------

void CfgArearecyclebin()
{
    char* key;
    getkeyval(&key, &val);
    strupr(strxcpy(CFG->arearecyclebin, key, sizeof(Echo)));

    if (*val)
    {
        if      (strieql(val, "NoAsk"))
            CFG->arearecyclebinask = false;
        else if (strieql(val, "Ask"))
            CFG->arearecyclebinask = true;
        else
            CFG->arearecyclebinask = make_bool(GetYesno(val));
    }
}

//  ------------------------------------------------------------------

void CfgArearename()
{

    char* key;
    getkeyval(&key, &val);
    CFG->arearename.push_back(EchoRen(key, strtrim(val)));
}

//  ------------------------------------------------------------------

