/*
 * dump-types.c --
 *
 *      Operations to dump the type hierarchy in a human readable format.
 *
 * Copyright (c) 1999 Frank Strauss, Technical University of Braunschweig.
 * Copyright (c) 1999 J. Schoenwaelder, Technical University of Braunschweig.
 *
 * See the file "COPYING" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 *
 * @(#) $Id: dump-types.c 8090 2008-04-18 12:56:29Z strauss $
 */

/*
 * Decide how we want to name the implicitely defined types.
 */

#include <config.h>

#include <stdio.h>
#include <string.h>
#include <ctype.h>

#include "smi.h"
#include "smidump.h"


static int noimplicit = 0;


typedef struct BaseTypeCount {
    SmiBasetype basetype;
    int         counter;
} BaseTypeCount;


static BaseTypeCount basetypes[] = {
    { SMI_BASETYPE_INTEGER32, 0 },
    { SMI_BASETYPE_OCTETSTRING, 0 },
    { SMI_BASETYPE_OBJECTIDENTIFIER, 0 },
    { SMI_BASETYPE_UNSIGNED32, 0 },
    { SMI_BASETYPE_INTEGER64, 0 },
    { SMI_BASETYPE_UNSIGNED64, 0 },
    { SMI_BASETYPE_FLOAT32, 0 },
    { SMI_BASETYPE_FLOAT64, 0 },
    { SMI_BASETYPE_FLOAT128, 0 },
    { SMI_BASETYPE_ENUM, 0 },
    { SMI_BASETYPE_BITS, 0 },
    { SMI_BASETYPE_UNKNOWN, 0 }
};


typedef struct TypeNode {
    SmiType	*smiType;
    SmiModule	*smiModule;
    SmiBasetype smiBasetype;
    struct TypeNode *nextNodePtr;
    struct TypeNode *childNodePtr;
} TypeNode;


static TypeNode typeRoot = {
    NULL, NULL, SMI_BASETYPE_UNKNOWN, NULL, NULL
};


static int pmodc = 0;
static SmiModule **pmodv = NULL;


static char getStatusChar(SmiStatus status)
{
    switch (status) {
    case SMI_STATUS_UNKNOWN:
	return '+';
    case SMI_STATUS_CURRENT:
	return '+';
    case SMI_STATUS_DEPRECATED:
	return 'x';
    case SMI_STATUS_MANDATORY:
        return '+';
    case SMI_STATUS_OPTIONAL:
	return '+';
    case SMI_STATUS_OBSOLETE:
	return 'o';
    }

    return ' ';
}



static char *getFlags(SmiModule *smiModule, SmiType *smiType)
{
    static char flags[4];
    int		i;
    
    memset(flags, 0, sizeof(flags));
    strcpy(flags, "---");

    switch (smiType->decl) {
    case SMI_DECL_IMPLICIT_TYPE:
	flags[0] = 'i';
	break;
    case SMI_DECL_TYPEASSIGNMENT:
	flags[0] = 'a';
	break;
    case SMI_DECL_TEXTUALCONVENTION:
    case SMI_DECL_TYPEDEF:
	flags[0] = 't';
	break;
    default:
	break;
    }

    for (i = 0; i < pmodc; i++) {
	if (strcmp(pmodv[i]->name, smiModule->name) == 0) {
	    break;
	}
    }

    if ((!smiModule) || (strlen(smiModule->name) == 0)) {
	flags[2] = 'b';
#if 0	/* xxx fixme */
    } else if (!moduleList) {
	flags[2] = '-';
    } else if (mPtr) {
	flags[2] = 'l';
#endif
    } else {
	flags[2] = 'i';
    }

    return flags;
}



static void initBaseTypeCount()
{
    int i;

    for (i = 0; i < sizeof(basetypes)/sizeof(BaseTypeCount); i++) {
	basetypes[i].counter = 0;
    }
}



static void incrBaseTypeCount(SmiBasetype basetype)
{
    int i;

    for (i = 0; i < sizeof(basetypes)/sizeof(BaseTypeCount); i++) {
	if (basetypes[i].basetype == basetype) {
	    basetypes[i].counter++;
	}
    }
}



static int getBaseTypeCount(SmiBasetype basetype)
{
    int i;

    for (i = 0; i < sizeof(basetypes)/sizeof(BaseTypeCount); i++) {
	if (basetypes[i].basetype == basetype) {
	    return basetypes[i].counter;
	}
    }

    return -1;
}



static char *getValueString(SmiValue *valuePtr, SmiType *typePtr)
{
    static char    s[1024];
    char           ss[9];
    int		   n;
    unsigned int   i;
    SmiNamedNumber *nn;
    SmiNode        *nodePtr;
    
    s[0] = 0;
    
    switch (valuePtr->basetype) {
    case SMI_BASETYPE_UNSIGNED32:
	sprintf(s, "%lu", valuePtr->value.unsigned32);
	break;
    case SMI_BASETYPE_INTEGER32:
	sprintf(s, "%ld", valuePtr->value.integer32);
	break;
    case SMI_BASETYPE_UNSIGNED64:
	sprintf(s, UINT64_FORMAT, valuePtr->value.unsigned64);
	break;
    case SMI_BASETYPE_INTEGER64:
	sprintf(s, INT64_FORMAT, valuePtr->value.integer64);
	break;
    case SMI_BASETYPE_FLOAT32:
    case SMI_BASETYPE_FLOAT64:
    case SMI_BASETYPE_FLOAT128:
	break;
    case SMI_BASETYPE_ENUM:
	for (nn = smiGetFirstNamedNumber(typePtr); nn;
	     nn = smiGetNextNamedNumber(nn)) {
	    if (nn->value.value.unsigned32 == valuePtr->value.unsigned32)
		break;
	}
	if (nn) {
	    sprintf(s, "%s", nn->name);
	} else {
	    sprintf(s, "%ld", valuePtr->value.integer32);
	}
	break;
    case SMI_BASETYPE_OCTETSTRING:
	for (i = 0; i < valuePtr->len; i++) {
	    if (!isprint((int)valuePtr->value.ptr[i])) break;
	}
	if (i == valuePtr->len) {
	    sprintf(s, "\"%s\"", valuePtr->value.ptr);
	} else {
            sprintf(s, "0x%*s", 2 * valuePtr->len, "");
            for (i=0; i < valuePtr->len; i++) {
                sprintf(ss, "%02x", valuePtr->value.ptr[i]);
                strncpy(&s[2+2*i], ss, 2);
            }
	}
	break;
    case SMI_BASETYPE_BITS:
	sprintf(s, "(");
	for (i = 0, n = 0; i < valuePtr->len * 8; i++) {
	    if (valuePtr->value.ptr[i/8] & (1 << (7-(i%8)))) {
		if (n)
		    sprintf(&s[strlen(s)], ", ");
		n++;
		for (nn = smiGetFirstNamedNumber(typePtr); nn;
		     nn = smiGetNextNamedNumber(nn)) {
		    if (nn->value.value.unsigned32 == i)
			break;
		}
		if (nn) {
		    sprintf(&s[strlen(s)], "%s", nn->name);
		} else {
		    sprintf(s, "%d", i);
		}
	    }
	}
	sprintf(&s[strlen(s)], ")");
	break;
    case SMI_BASETYPE_UNKNOWN:
	break;
    case SMI_BASETYPE_POINTER:
	break;
    case SMI_BASETYPE_OBJECTIDENTIFIER:
	nodePtr = smiGetNodeByOID(valuePtr->len, valuePtr->value.oid);
	if (!nodePtr) {
	    sprintf(s, "%s", nodePtr->name);
	} else {
	    strcpy(s, "");
	    for (i=0; i < valuePtr->len; i++) {
		if (i) strcat(s, ".");
		sprintf(&s[strlen(s)], "%u", valuePtr->value.oid[i]);
	    }
	}
	break;
    }

    return s;
}



static void addToTypeTree(TypeNode *root,
			  SmiModule *smiModule, SmiType *smiType)
{
    TypeNode  *newType, **typePtrPtr;
    SmiType   *smiParentType;
    SmiModule *smiParentModule;

    if (! root) {
	return;
    }

    smiParentType = smiGetParentType(smiType);
    smiParentModule = smiParentType ? smiGetTypeModule(smiParentType) : NULL;

    if ((root->smiModule == smiParentModule && root->smiType == smiParentType)
	|| (! root->smiModule && ! root->smiType
	    && root->smiBasetype == smiType->basetype)) {

	 newType = xmalloc(sizeof(TypeNode));
	 newType->smiModule = smiModule;
	 newType->smiType = smiType;
	 newType->smiBasetype = smiType->basetype;
	 newType->childNodePtr = NULL;
	 newType->nextNodePtr = NULL;

	 for (typePtrPtr = &(root->childNodePtr);
	      *typePtrPtr; typePtrPtr = &((*typePtrPtr)->nextNodePtr)) ;
	 *typePtrPtr = newType;
	 return;
     }

     if (root->nextNodePtr) {
	 addToTypeTree(root->nextNodePtr, smiModule, smiType);
     }
     
     if (root->childNodePtr) {
	 addToTypeTree(root->childNodePtr, smiModule, smiType);
     }
}



static void freeTypeTree(TypeNode *root)
{
    if (root->childNodePtr) {
	if (root->childNodePtr->smiModule) {
	    freeTypeTree(root->childNodePtr);
	    root->childNodePtr = NULL;
	} else {
	    freeTypeTree(root->childNodePtr);
	}
    }
    
    if (root->nextNodePtr) {
	if (root->nextNodePtr->smiModule) {
	    freeTypeTree(root->nextNodePtr);
	    root->nextNodePtr = NULL;
	} else {
	    freeTypeTree(root->nextNodePtr);
	}
    }
    
    if (root->smiModule) {
	xfree(root);
    }
}



static TypeNode *findInTypeTree(TypeNode *root,
				SmiModule *smiModule, SmiType *smiType)
{
    TypeNode *result = NULL;
    
    if (root->smiModule && root->smiModule == smiModule
	&& smiType->name
	&& root->smiType && root->smiType == smiType) {
	result = root;
    }
    
    if (!result && root->childNodePtr) {
	result = findInTypeTree(root->childNodePtr, smiModule, smiType);
    }
    
    if (!result && root->nextNodePtr) {
	result = findInTypeTree(root->nextNodePtr, smiModule, smiType);
    }
    
    return result;
}



static char* getTypeName(TypeNode *typeNode)
{
    SmiRefinement *smiRefinement;
    SmiType *smiType;
    char *name = "?";

    if (typeNode->smiType->name) {
#if 1
	return xstrdup(typeNode->smiType->name);
#else
	char *s;
	s = xmalloc(strlen(typeNode->smiType->name)+
		    strlen(typeNode->smiModule ? typeNode->smiModule->name : "") +3);
	sprintf(s, "%s::%s", typeNode->smiModule ? typeNode->smiModule->name : "",
		typeNode->smiType->name);
	return s;
#endif
	
    } else if (typeNode->smiModule) {
	SmiNode *smiNode;

	for (smiNode = smiGetFirstNode(typeNode->smiModule, SMI_NODEKIND_ANY);
	     smiNode;
	     smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ANY)) {
	    if (smiGetNodeType(smiNode) == typeNode->smiType) {
		name = xmalloc(strlen(smiNode->name) + 3);
		sprintf(name, "(%s)", smiNode->name);
		return name;
	    }
	}

	for (smiNode = smiGetFirstNode(typeNode->smiModule,
				       SMI_NODEKIND_COMPLIANCE);
	     smiNode;
	     smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_COMPLIANCE)) {
	    for(smiRefinement = smiGetFirstRefinement(smiNode);
		smiRefinement;
		smiRefinement = smiGetNextRefinement(smiRefinement)) {
		smiType = smiGetRefinementType(smiRefinement);
		if (smiType == typeNode->smiType) {
		    smiNode = smiGetRefinementNode(smiRefinement);
		    name = xmalloc(strlen(smiNode->name) + 3);
		    sprintf(name, "(%s)", smiNode->name);
		    return name;
		}
		smiType = smiGetRefinementWriteType(smiRefinement);
		if (smiType == typeNode->smiType) {
		    smiNode = smiGetRefinementNode(smiRefinement);
		    name = xmalloc(strlen(smiNode->name) + 3);
		    sprintf(name, "(%s)", smiNode->name);
		    return name;
		}
	    }
	}
    }

    return xstrdup(name);
}



static void fprintRestrictions(FILE *f, SmiType *smiType)
{
    SmiNamedNumber *nn;
    SmiRange       *range;
    char           s1[40], s2[40];
    int            i;
    
    if ((smiType->basetype == SMI_BASETYPE_ENUM) ||
	(smiType->basetype == SMI_BASETYPE_BITS)) {
	for(i = 0, nn = smiGetFirstNamedNumber(smiType);
	    nn ; nn = smiGetNextNamedNumber(nn), i++) {
	    fprintf(f, "%s%s(%ld)", (i == 0) ? " {" : ", ",
		   nn->name, nn->value.value.integer32);
	}
	if (i) fprintf(f, "}");
    } else {
	for(i = 0, range = smiGetFirstRange(smiType);
	    range ; range = smiGetNextRange(range), i++) {
	    strcpy(s1, getValueString(&range->minValue, smiType));
	    strcpy(s2, getValueString(&range->maxValue, smiType));
	    fprintf(f, "%s%s", (i == 0) ? " [" : ", ", s1);
	    if (strcmp(s1, s2)) fprintf(f, "..%s", s2);
	}
	if (i) fprintf(f, "]");
    }
}



static void fprintTypeTree(FILE *f, TypeNode *root, char *prefix)
{
    TypeNode *typeNode, *nextNode;
    char *name;
    int namelen = -1;

    if (root->smiModule) {
	fprintf(f, "%s  |\n", prefix);
    }

    for (typeNode = root; typeNode; typeNode = typeNode->nextNodePtr) {
	if (typeNode->smiType) {
	    int len;
	    name = getTypeName(typeNode);
	    len = strlen(name);
	    if (len > namelen) namelen = len;
	    xfree(name);
	}
    }
    
    for (typeNode = root; typeNode; typeNode = typeNode->nextNodePtr) {
 	if (typeNode != &typeRoot) {
	    char c = '+', *flags;
	    if (typeNode->smiType) {
		name = getTypeName(typeNode);
		c = getStatusChar(typeNode->smiType->status);
		if (getBaseTypeCount(typeNode->smiBasetype)) {
		    flags = getFlags(typeNode->smiModule, typeNode->smiType);
		    if (flags && *flags) {
			fprintf(f, "%s  %c-- %s %-*s", prefix, c, flags,
				namelen, name);
		    } else {
			fprintf(f, "%s  %c--%-*s", prefix, c,
				namelen, name);
		    }
		    fprintRestrictions(f, typeNode->smiType);
		    if (typeNode->smiType->format) {
			fprintf(f, "\t\"%s\"", typeNode->smiType->format);
		    }
		    fprintf(f, "\n");
		}
		xfree(name);
	    } else {
		fprintf(f, "xxxx\n");
	    }
 	}
 	if (typeNode->childNodePtr) {
 	    char *newprefix;
 	    newprefix = xmalloc(strlen(prefix)+10);
 	    strcpy(newprefix, prefix);
 	    if (typeNode != &typeRoot) {
		for (nextNode = typeNode->nextNodePtr;
		     nextNode; nextNode = nextNode->nextNodePtr) {
		    if (getBaseTypeCount(nextNode->smiBasetype)) {
			break;
		    }
		}
 		if (nextNode) {
  		    strcat(newprefix, "  |");
 		} else {
 		    strcat(newprefix, "   ");
 		}
 	    }
 	    fprintTypeTree(f, typeNode->childNodePtr, newprefix);
 	    xfree(newprefix);
	    for (nextNode = typeNode->nextNodePtr;
		 nextNode; nextNode = nextNode->nextNodePtr) {
		if (getBaseTypeCount(nextNode->smiBasetype)) {
		    break;
		}
	    }
	    if (nextNode) {
		fprintf(f, "%s  |\n", prefix);
	    }
 	}
    }
}



static void addType(SmiType *smiType)
{
    SmiModule *smiModule;
    SmiType   *smiParentType;

    smiModule = smiGetTypeModule(smiType);
    if (! smiModule) {
	return;
    }
    
    if (findInTypeTree(&typeRoot, smiModule, smiType)) {
	return;
    }

    smiParentType = smiGetParentType(smiType);
    if (smiParentType && smiParentType->name) {
 	if (smiParentType) {
 	    addType(smiParentType);
 	}
    }

    addToTypeTree(&typeRoot, smiModule, smiType);
    incrBaseTypeCount(smiType->basetype);
}



static void dumpTypes(int modc, SmiModule **modv, int flags, char *output)
{
    SmiNode	  *smiNode;
    SmiType       *smiType;
    SmiRefinement *smiRefinement;
    int		  i;
    FILE          *f = stdout;
    const unsigned int nodekind = SMI_NODEKIND_COLUMN | SMI_NODEKIND_SCALAR;
    
    if (output) {
	f = fopen(output, "w");
	if (!f) {
	    fprintf(stderr, "smidump: cannot open %s for writing: ", output);
	    perror(NULL);
	    exit(1);
	}
    }

    pmodc = modc;
    pmodv = modv;
    
    initBaseTypeCount();

    for (i = 0; i < modc; i++) {

	if (! (flags & SMIDUMP_FLAG_UNITE)) {
	    initBaseTypeCount();
	}

	for (smiType = smiGetFirstType(modv[i]);
	     smiType;
	     smiType = smiGetNextType(smiType)) {
	    addType(smiType);
	}

	for (smiNode = smiGetFirstNode(modv[i], nodekind);
	     smiNode;
	     smiNode = smiGetNextNode(smiNode, nodekind)) {
	    smiType = smiGetNodeType(smiNode);
	    if (smiType) {
		if (!noimplicit && smiType->decl == SMI_DECL_IMPLICIT_TYPE) {
		    addType(smiType);
		}
		incrBaseTypeCount(smiType->basetype);
	    }
	}
	
	for (smiNode = smiGetFirstNode(modv[i], SMI_NODEKIND_COMPLIANCE);
	     smiNode;
	     smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_COMPLIANCE)) {
	    for (smiRefinement = smiGetFirstRefinement(smiNode);
		 smiRefinement;
		 smiRefinement = smiGetNextRefinement(smiRefinement)) {
		smiType = smiGetRefinementType(smiRefinement);
		if (smiType) {
		    if (!noimplicit
			&& smiType->decl == SMI_DECL_IMPLICIT_TYPE) {
			addType(smiType);
		    }
		    incrBaseTypeCount(smiType->basetype);
		}
		smiType = smiGetRefinementWriteType(smiRefinement);
		if (smiType) {
		    if (!noimplicit
			&& smiType->decl == SMI_DECL_IMPLICIT_TYPE) {
			addType(smiType);
		    }
		    incrBaseTypeCount(smiType->basetype);
		}
	    }
	}

	if (! (flags & SMIDUMP_FLAG_UNITE)) {
	    if (! (flags & SMIDUMP_FLAG_SILENT)) {
		fprintf(f, "# %s type derivation tree (generated by smidump "
			SMI_VERSION_STRING ")\n\n", modv[i]->name);
	    }
	    if (! (flags & SMIDUMP_FLAG_SILENT) && (flags & SMIDUMP_FLAG_ERROR)) {
		fprintf(f, "# WARNING: this output may be incorrect due to "
			"significant parse errors\n\n");
	    }
	    fprintTypeTree(f, &typeRoot, "");
	    freeTypeTree(&typeRoot);
	}
    }

    if (flags & SMIDUMP_FLAG_UNITE) {
	if (! (flags & SMIDUMP_FLAG_SILENT)) {
	    fprintf(f, "# united type derivation tree (generated by smidump "
		   SMI_VERSION_STRING ")\n\n");
	}
	if (! (flags & SMIDUMP_FLAG_SILENT) && (flags & SMIDUMP_FLAG_ERROR)) {
	    fprintf(f, "# WARNING: this output may be incorrect due to "
		    "significant parse errors\n\n");
	}
	fprintTypeTree(f, &typeRoot, "");
	freeTypeTree(&typeRoot);
    }

    if (fflush(f) || ferror(f)) {
	perror("smidump: write error");
	exit(1);
    }

    if (output) {
	fclose(f);
    }
}



void initTypes()
{
    static SmidumpDriverOption opt[] = {
	{ "no-implicit", OPT_FLAG, &noimplicit, 0,
	  "ignore implicit type definitions"},
        { 0, OPT_END, 0, 0 }
    };
    
    static SmidumpDriver driver = {
	"types",
	dumpTypes,
	SMI_FLAG_NODESCR,
	0,
	"recursive list of all derived types",
	opt,
	NULL
    };
    
    smidumpRegisterDriver(&driver);
}