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


// SOL9
// 2011/1/2
// 2011/1/14 Modified data member to be a pointer to T.

#pragma once
#include <sol/dns/DnsObject.h>
#include <sol/net/IPv4Address.h>
#include <sol/net/IPv6Address.h>
#include <sol/ArgT.h>
#include <sol/dns/DnsData.h>

/*
typedef struct _DnsRecordFlags {
  DWORD Section  :2;
  DWORD Delete  :1;
  DWORD CharSet  :2;
  DWORD Unused  :3;
  DWORD Reserved  :24;
} DNS_RECORD_FLAGS;
*/

namespace SOL {

template <class T> class DnsRecordT :public DnsObject {

private:
    StringT<TCHAR>     name;

    WORD    type;

    DWORD    ttl;

    DNS_RECORD_FLAGS  flags;

    WORD    dataLength;

    T*        data;

public:
    /**
     * Constructor
     */
    DnsRecordT()
    :name(_T("")),
    type(0),
    dataLength(0),
    data(NULL)
    {
        memset(&flags, 0, sizeof(flags));
    }

public:
    ~DnsRecordT()
    {
        clear();
    }


public:
    void clear()
    {
        if (data) {
            delete [] (BYTE*)data;
            data = NULL;
        }
    }


public:
    // 2011/1/14 Modifed to use a dataLength parameter.
    void copy(const TCHAR* pName, WORD wType, DWORD dwTtl, DNS_RECORD_FLAGS& sFlags, WORD wDataLength, T& t)
    {
        name = pName;
        type = wType;
        ttl  = dwTtl;
        memcpy(&flags, &sFlags, sizeof(flags));
        dataLength = wDataLength;

        if (dataLength>0) {
            data = (T*)new BYTE[dataLength];
            memcpy(data, &t, dataLength);
        }
    }


public:
    const TCHAR* getName()
    {
        return (const TCHAR*)name;
    }

public:
    WORD getType()
    {
        return type;
    }

public:
    DNS_RECORD_FLAGS& getFlags()
    {
        return flags;
    }

public:
    T& getData()
    {
        return *data;
    }

public:
    operator const T*() const 
    {
        return data;
    }

public:
    const TCHAR* getFlagsSection(int sec)
    {
        const ArgT<TCHAR> names[]={
            {_T("Question"),    DNSREC_QUESTION},
            {_T("Answer"),        DNSREC_ANSWER},
            {_T("Authority"),    DNSREC_AUTHORITY},
            {_T("Additional"),    DNSREC_ADDITIONAL}
        };
        const TCHAR* name=NULL;
        for (int i=0; i<SizeOf(names); i++) {
            if (names[i].value == sec) {
                name=names[i].name;
                break;
            }
        }
        return name;
    }

public:
    const TCHAR* getFlagsCharSet(int sec)
    {
        const ArgT<TCHAR> names[]={
            {_T("Unknown"), DnsCharSetUnknown},
            {_T("Unicode"), DnsCharSetUnicode},
            {_T("Utf8"), DnsCharSetUtf8},
            {_T("Ansi"), DnsCharSetAnsi}
        };
        const TCHAR* name=NULL;
        for (int i=0; i<SizeOf(names); i++) {
            if (names[i].value == sec) {
                name=names[i].name;
                break;
            }
        }
        return name;
    }

public:
    void display()
    {
        _tprintf(_T("Name=%s\n"), (const TCHAR*)name);
        const TCHAR* sec = getFlagsSection(flags.Section);
        if (sec) {
            _tprintf(_T("Section=%s\n"), sec);
        }
        const TCHAR* charset = getFlagsCharSet(flags.CharSet);
        if (charset) {
            _tprintf(_T("CharSet=%s\n"), charset);
        }
        _tprintf(_T("Ttl=%d(seconds)\n"), ttl);
        _tprintf(_T("dataLength=%d\n"), dataLength);
        
        DnsData dnsData;
        dnsData.display(*data);
        _tprintf(_T("\n"));

    }
};

}