/*
 * DnsRecord.h 
 * Copyright (c) 2011 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


// SOL9 2.0

// 2011/1/18 

#pragma once
#include <sol/dns/DnsObject.h>
#include <sol/dns/IPv4AddressArray.h>
#include <sol/net/IPv4AddressInfoList.h>
#include <sol/dns/DnsData.h>

namespace SOL {

class DnsRecord :public DnsObject {

private:
    PDNS_RECORD pRecord;

public:
    /**
     * Constructor
     */
    DnsRecord()
        :pRecord(NULL)
    {
    }

public:
    /**
     * Destrucotr
     */
    virtual ~DnsRecord() 
    {
        pRecord = NULL;
    }

public:
    PDNS_RECORD getRecord()
    {
        return this->pRecord;
    }

public:
    void setRecord(DNS_RECORD* aRecord)
    {
        this->pRecord = aRecord;    
    }

public:
    void addRecord(DNS_RECORD* aRecord)
    {
    //If this->record is NULL, then set the above aRecord to this->record;
        if (this->pRecord == NULL) {
            this->pRecord = aRecord;
        } else {
            //else get a last DNS_RECORD from this->pRecord, and set the above aRecord to it;
            DNS_RECORD* ptr = this->pRecord;
            while (ptr->pNext != NULL) {
                ptr = ptr ->pNext;
            }
            ptr ->pNext = aRecord;
        }
    }


public:
    int getCount() 
    {
        PDNS_RECORD ptr = this->pRecord;
        int count = 0;
        while (ptr) {
            count++;
            ptr = ptr->pNext;
        } 
        return count;
    }

public:
    PDNS_RECORD getNth(int n) 
    {
        PDNS_RECORD rec = NULL;
        PDNS_RECORD ptr = this->pRecord;
        int count = 0;
        while (ptr) {
            if (count == n) {
                rec = ptr;
                break;
            }
            count++;
            ptr = ptr->pNext;
        } 
        return rec;
    }


public:
    virtual void display()
    {
        PDNS_RECORD ptr = this->pRecord;
        _tprintf(_T("<?xml version=\"1.0\"?>\n"));

        _tprintf(_T("<DNS_RECORD_LIST>\n"));
        while (ptr) {
            display(ptr);    
            ptr = ptr->pNext;
        } 
        _tprintf(_T("</DNS_RECORD_LIST>\n"));
    }

public:
    void display(PDNS_RECORD ptr)
    {
        DnsData dnsData;
        _tprintf(_T("<DNS_RECORD Name=\"%s\" Type=\"%d\" Section=\"%d\" CharSet=\"%d\" DataLength=\"%d\">\n"), 
            ptr->pName, 
            ptr->wType,
            ptr->Flags.S.Section,
            ptr->Flags.S.CharSet,
            ptr->wDataLength);

        switch(ptr->wType)
        {
        case DNS_TYPE_A:
            dnsData.display(ptr->Data.A, _T("A"));
            break;

        case DNS_TYPE_SOA:
            dnsData.display(ptr->Data.Soa, _T("SOA"));
            break;

        //<Data T="DNS_PTR_DATA">
        case DNS_TYPE_PTR:
            dnsData.display(ptr->Data.Ptr, _T("PTR"));
            break;

        case DNS_TYPE_NS:
            dnsData.display(ptr->Data.Ns, _T("NS"));
            break;
        
        case DNS_TYPE_CNAME:
            dnsData.display(ptr->Data.Cname, _T("CNAME"));
            break;

        case DNS_TYPE_DNAME:
            dnsData.display(ptr->Data.Dname, _T("DNAME"));
            break;

        case DNS_TYPE_MD:
            dnsData.display(ptr->Data.Md, _T("MD"));
            break;

        case DNS_TYPE_MF:
            dnsData.display(ptr->Data.Mf, _T("MF"));
            break;

        case DNS_TYPE_MG:
            dnsData.display(ptr->Data.Mg, _T("MG"));
            break;

        case DNS_TYPE_MR:
            dnsData.display(ptr->Data.Mr, _T("MR"));
            break;
        //</Data>

        //<Data T="DNS_MINFO_DATA">
        case DNS_TYPE_MINFO:
            dnsData.display(ptr->Data.Minfo, _T("MINFO"));
            break;

        case DNS_TYPE_RP:
            dnsData.display(ptr->Data.Rp, _T("RP"));
            break;
        //</Data>

        //<Data T="DNS_MX_DATA">
        case DNS_TYPE_MX:
            dnsData.display(ptr->Data.Mx, _T("MX"));
            break;

        case DNS_TYPE_AFSDB:
            dnsData.display(ptr->Data.Afsdb, _T("AFSDB"));
            break;

        case DNS_TYPE_RT:
            dnsData.display(ptr->Data.Rt, _T("RT"));
            break; 
        //</Data>

        //<Data T="DNS_TYPE_TEXT">
        case DNS_TYPE_TEXT:
            dnsData.display(ptr->Data.Txt, _T("TEXT"));
            break;

        case DNS_TYPE_HINFO:
            dnsData.display(ptr->Data.Hinfo, _T("HINFO"));
            break;

        case DNS_TYPE_ISDN:
            dnsData.display(ptr->Data.Isdn, _T("ISDN"));
            break;
        case DNS_TYPE_X25:
            dnsData.display(ptr->Data.X25, _T("X25"));
            break;
        //</Data>

        case DNS_TYPE_NULL:
            dnsData.display(ptr->Data.Null, _T("NULL"));
            break;

        case DNS_TYPE_WKS:
            dnsData.display(ptr->Data.Wks, _T("WKS"));
            break;

        case DNS_TYPE_AAAA:
            dnsData.display(ptr->Data.AAAA, _T("AAAA"));
            break;

        case DNS_TYPE_KEY:
            dnsData.display(ptr->Data.Key, _T("KEY"));
            break;

        case DNS_TYPE_SIG:
            dnsData.display(ptr->Data.Sig, _T("SIG"));
            break;

        case DNS_TYPE_ATMA:
            dnsData.display(ptr->Data.Atma, _T("ATMA"));
            break;

        case DNS_TYPE_NXT:
            dnsData.display(ptr->Data.Nxt, _T("NXT"));
            break;
    
        case DNS_TYPE_SRV:
            dnsData.display(ptr->Data.Srv, _T("SRV"));
            break;

        case DNS_TYPE_NAPTR:
            dnsData.display(ptr->Data.Naptr, _T("NAPTR"));
            break;

        case DNS_TYPE_TKEY:
            dnsData.display(ptr->Data.Tkey, _T("TKEY"));
            break;

        case DNS_TYPE_TSIG:
            dnsData.display(ptr->Data.Tsig, _T("TSIG"));
            break;

        case DNS_TYPE_WINS:
            dnsData.display(ptr->Data.Wins, _T("WINS"));
            break;

        case DNS_TYPE_WINSR:
            dnsData.display(ptr->Data.WinsR, _T("WINSR"));
            break;

        default:
            break;
        }
        _tprintf(_T("</DNS_RECORD>\n"));
    }

};

}