#!/usr/bin/python

# Summarize.py
# 2005 FEB 13 . ccr

# Summarizes NHTSA FARS databases on standard input and outputs
# selected variables in "comma separated value" (csv) format on
# standard output.  Takes one parameter:  Year.

# 2005 MAR 14 . ccr . Select by state.
# 2005 MAR 16 . ccr . Discriminate by state and helmet enforcement.

from __future__ import division
from math import *
import sys
import Describe

ZERO=0
SPACE=' '
NULL=''
NUL='\x00'
NA=-1

FLD_REQ=[
    'CASE STATE',
    'BODY TYPE',
    'MODEL YEAR',
    'VINA DECODES BODY TYPE',
    'VINA DECODES MOTORCYCLE DISPLACEMENT',
    'PERSON TYPE',
    'AGE',
    'SEX',
    'INJURY SEVERITY',
    'LICENSE STATE',
    'ROADWAY FUNCTION CLASS',
    'MANUAL RESTRAINT',
    'RESTRAINT SYSTEM-USE',
    ]

MOTORCYCLE_BODY_TYPES= ['EN','MK','MM','MR','MS','MX','RS','RT','T ','T',]
AUTO_BODY_TYPES=       ['2D','2F','2H','2L','2P','2T','3D','3P','4D','4H',
                        '4L','4P','4T','CP','CV','HB','HT','LB','NB','RD',
                        'SD','SW',]
SUV_BODY_TYPES=        ['2W','4W','S2','UT','LL',]
LIGHT_TRUCK_BODY_TYPES=['CB','CC','CG','CH','CL','CW','CY','EC','ES','EV',
                        'EW','FB','FC','IC','IE','PC','PK','PN','PS','SN',
                        'SV','TB','VN','VW','YY',]
UNKNOWN_BODY_TYPE=     ['99','  ',NULL,]

class cCrash(object):
    def __init__(self,aRec,aVehicleList):
        self.fRec=aRec
        self.fVehicleList=aVehicleList
        return
    def GetState(self):
        return self.fRec['CASE STATE']
    def GetRFC(self):
        return self.fRec['ROADWAY FUNCTION CLASS']
    def IsMultiVehicle(self):
        return len(self.fVehicleList)>1
    def IsMotorcycleRelated(self):
        for __VehicleRec in self.fVehicleList.itervalues():
            __Vehicle=cVehicle(__VehicleRec)
            if __Vehicle.IsMotorcycle():
                return True
        return False
    def IsRural(self):
        return ('01'<=self.GetRFC()<='09')
    def IsUrban(self):
        return ('11'<=self.GetRFC()<='19')

class cVehicle(object):
    def __init__(self,aRec):
        self.fRec=aRec
        return
    def GetVINBodyTypeCode(self):
        return self.fRec['VINA DECODES BODY TYPE']
    def GetBodyType(self):
        return self.fRec['BODY TYPE']
    def GetDisplacement(self):
        try:
            __Result=int(self.fRec['VINA DECODES MOTORCYCLE DISPLACEMENT'].strip())
        except ValueError:
            __Result=ZERO
        return __Result
    def GetModelYear(self):
        try:
            __Result=int(self.fRec['MODEL YEAR'])
        except ValueError:
            __Result=ZERO
        if YEAR<'1998':
            if __Result in [99]:
                __Result=9999
            else:
                __Result=__Result+1900
        return __Result
    def GetLicenseState(self):
        return self.fRec['LICENSE STATE']
    def IsMotorcycle(self):
        if YEAR<'1991':
            __Result=('20'<=self.GetBodyType()<='29')
        else:
            __Result=('80'<=self.GetBodyType()<='89')
#        __Result=(self.GetVINBodyTypeCode() in MOTORCYCLE_BODY_TYPES)
        return __Result
    def IsLE250Displacement(self):
        return (ZERO<self.GetDisplacement()<=250)
    def IsGE1000Displacement(self):
        return (1000<=self.GetDisplacement()<9999)
    def IsUnknownDisplacement(self):
        return (self.GetDisplacement() in [ZERO,9999])
    def IsCurrentModelYear(self):
        return (self.GetModelYear()==IYEAR)
    def IsBefore1980ModelYear(self):
        return (self.GetModelYear()<1980)
    def IsUnknownModelYear(self):
        return (self.GetModelYear() in [ZERO,1900,9999])
    def IsUnknownLicenseState(self):
        return (self.GetLicenseState() in ['99'])
    def IsLicenseInState(self,aState):
        return (self.GetLicenseState()==aState)
    
class cPerson(object):
    def __init__(self,aRec,aVehicleRec):
        self.fRec=aRec
        if aVehicleRec is None:
            self.fVehicle=None
        else:
            self.fVehicle=cVehicle(aVehicleRec)
        return
    def GetPersonType(self):
        return self.fRec['PERSON TYPE']
    def GetAge(self):
        return self.fRec['AGE']
    def GetSex(self):
        return self.fRec['SEX']
    def GetInjurySeverity(self):
        return self.fRec['INJURY SEVERITY']
    def GetRestraint(self):
        if YEAR<'1991':
            return self.fRec['MANUAL RESTRAINT']
        else:
            return self.fRec['RESTRAINT SYSTEM-USE']
    def IsNonMotorist(self):
        return (self.fVehicle is None)
    def IsDriver(self):
        return (self.GetPersonType() in ['1','01'])
    def Is40orOver(self):
        return ('40'<=self.GetAge()<='97')
    def IsEarly30s(self):
        return ('30'<=self.GetAge()<='34')
    def IsUnder25(self):
        return (ZERO<=self.GetAge()<'25')
    def IsAgeUnknown(self):
        return (self.GetAge() in ['98','99'])
    def IsMale(self):
        return (self.GetSex() in ['1'])
    def IsFemale(self):
        return (self.GetSex() in ['2'])
    def IsFatality(self):
        return (self.GetInjurySeverity() in ['4'])
    def IsOnMotorcycle(self):
        return (not self.IsNonMotorist()) and self.fVehicle.IsMotorcycle()
    def IsHelmetProper(self):
        return (self.GetRestraint() in ['05'])
    def IsHelmetImproper(self):
        return (self.GetRestraint() in ['15'])
    def IsHelmetNone(self):
        return (self.GetRestraint() in ['00'])

class cCounter(object):
    def __init__(self,aCaption):
        self.fCaption=aCaption
        self.fCount={}
        return
    def Bump(self,aState,aValue=1):
        self.fCount[aState]=self.fCount.get(aState,ZERO)+1
        self.fCount['99']=self.fCount.get('99',ZERO)+1
        return
    def GetCSV(self,aStates):
        __Result=NULL
        for __State in aStates:
            __Result=__Result+'%s,"%s",%i\n' % (__State,self.fCaption,self.fCount.get(__State,ZERO))
        return __Result

class cMean(cCounter):
    def __init__(self,aCaption):
        cCounter.__init__(self,aCaption)
        self.fSum={}
        return
    def Bump(self,aState,aValue):
        cCounter.Bump(self,aState)
        self.fSum[aState]=self.fSum.get(aState,ZERO)+aValue
        self.fSum['99']=self.fSum.get('99',ZERO)+aValue
        return
    def GetCSV(self,aStates):
        __Result=NULL
        for __State in aStates:
            __Count=self.fCount.get(__State,ZERO)
            __Sum=self.fSum.get(__State,ZERO)
            if __Count==ZERO:
                __Result=__Result+'%s,"%s",""\n' % (__State,self.fCaption)
            else:
                __Result=__Result+'%s,"%s",%f\n' % (__State,self.fCaption,__Sum/__Count)
        return __Result

class cMedian(cCounter):
    def __init__(self,aCaption):
        cCounter.__init__(self,aCaption)
        self.fList={}
        return
    def Bump(self,aState,aValue):
        self.fList.setdefault(aState,[]).append(aValue)
        self.fList.setdefault('99',[]).append(aValue)
        return
    def GetCSV(self,aStates):
        __Result=NULL
        for __State in aStates:
            __List=self.fList.get(__State,[])
            __Len=len(__List)
            if __Len==ZERO:
                __Result=__Result+'%s,"%s Q1",""\n%s,"%s Q2",""\n%s,"%s Q3",""\n' % \
                          (__State,self.fCaption,__State,self.fCaption,__State,self.fCaption)
            else:
                __List.sort()
                __Q=__Len/4
                __Q1=__List[int(__Q)]
                __Q2=__List[int(__Q+__Q)]
                __Q3=__List[int(__Q+__Q+__Q)]
                __Result=__Result+'%s,"%s Q1",%f\n%s,"%s Q2",%f\n%s,"%s Q3",%f\n' % \
                          (__State,self.fCaption,__Q1,__State,self.fCaption,__Q2,__State,self.fCaption,__Q3)
        return __Result

class cMode(cCounter):
    def __init__(self,aCaption):
        cCounter.__init__(self,aCaption)
        self.fList={}
        return
    def Bump(self,aState,aValue):
        __List=self.fList.setdefault(aState,{})
        __List[aValue]=__List.get(aValue,ZERO)+1
        __List=self.fList.setdefault('99',{})
        __List[aValue]=__List.get(aValue,ZERO)+1
        return
    def GetCSV(self,aStates):
        __Result=NULL
        for __State in aStates:
            __List=self.fList.get(__State,{})
            __Len=len(__List)
            if __Len==ZERO:
                __Result=__Result+'%s,"%s",""\n' % (__State,self.fCaption)
            else:
                __Invert=[(__Count,__Value) for (__Value,__Count) in __List.items()]
                __Invert.sort()
                (__Count,__Value)=__Invert[-1]
                __Result=__Result+'%s,"%s",%s\n' % (__State,self.fCaption,__Value)
        return __Result

class cCounterList(list):
    def append(self,aItem):
        list.append(self,aItem)
        return aItem
    def WriteCSV(self,aYear,aStates):
        sys.stdout.write('"State","Year","%s"\n' % (aYear))
        for __Item in self:
            sys.stdout.write(__Item.GetCSV(aStates))
        return

def TallyCrash(aCrash,aVehicleList,aPersonList):
    __Crash=cCrash(aCrash,aVehicleList)
    __State=__Crash.GetState()
    __Crashes.Bump(__State)
    if __Crash.IsMotorcycleRelated():__MCCrashes.Bump(__State)
    for __PersonRec in aPersonList.itervalues():
        __VehicleKey=__PersonRec['VEHICLE NUMBER']
        __Person=cPerson(__PersonRec,aVehicleList.get(__VehicleKey,None))
        __Persons.Bump(__State)
        if __Person.IsDriver():__Drivers.Bump(__State)
        if __Person.IsFatality():__Fatalities.Bump(__State)
        if __Person.IsOnMotorcycle():
            __Vehicle=__Person.fVehicle
            if __Vehicle.IsUnknownModelYear():
                __MCAge=None
            else:
                __MCAge=IYEAR-__Vehicle.GetModelYear()
            if __Person.IsFatality():
                __MCFatalities.Bump(__State)
                if __Person.IsHelmetImproper():__MCFatalitiesHelmetImproper.Bump(__State)
                if __Person.IsHelmetProper():__MCFatalitiesHelmetProper.Bump(__State)
                if __Person.IsHelmetNone():__MCFatalitiesHelmetNone.Bump(__State)
                if __MCAge is None:
                    pass
                else:
                    __FatalitiesMCMeanAge.Bump(__State,__MCAge)
                    if __Person.IsHelmetProper():__FatalitiesHelmetProperMCMeanAge.Bump(__State,__MCAge)
                    if __Person.IsHelmetNone():__FatalitiesHelmetNoneMCMeanAge.Bump(__State,__MCAge)
            if __Person.IsDriver():
                __MCDrivers.Bump(__State)
                if __Person.Is40orOver():__MCDrivers40orOver.Bump(__State)
                if __Person.IsUnder25():__MCDriversUnder25.Bump(__State)
                if __Vehicle.IsLE250Displacement():__MCsLE250Displacement.Bump(__State)
                if __Vehicle.IsGE1000Displacement():__MCsGE1000Displacement.Bump(__State)
                if __Vehicle.IsUnknownDisplacement():__MCsUnknownDisplacement.Bump(__State)
                if __MCAge is None:
                    __MCsUnknownModelYear.Bump(__State)
                else:
                    __MCMeanAge.Bump(__State,__MCAge)
    return

YEAR=sys.argv[1]
__States=['99']+sys.argv[2:]
IYEAR=int(YEAR)
__FARS=Describe.Open(YEAR,aFldReq=FLD_REQ,aDebug=False)
__FARS.fTallyCrashEpilog=TallyCrash
__List=cCounterList()
__Crashes=__List.append(cCounter('Crashes'))
__MCCrashes=__List.append(cCounter('MC Crashes'))
__Persons=__List.append(cCounter('Persons'))
__Drivers=__List.append(cCounter('Drivers'))
__MCDrivers=__List.append(cCounter('MC Drivers'))
__MCDriversUnder25=__List.append(cCounter('MC Drivers Under 25'))
__MCDrivers40orOver=__List.append(cCounter('MC Drivers 40 or Over'))
__Fatalities=__List.append(cCounter('Fatalities'))
__MCFatalities=__List.append(cCounter('MC-Rider Fatalities'))
__MCFatalitiesHelmetProper=__List.append(cCounter('MC-Rider Fatalities with Helmet'))
__MCFatalitiesHelmetImproper=__List.append(cCounter('MC-Rider Fatalities with Improper Helmet'))
__MCFatalitiesHelmetNone=__List.append(cCounter('MC-Rider Fatalities without Helmet'))
__MCsUnknownDisplacement=__List.append(cCounter('MCs Unknown Displacement'))
__MCsLE250Displacement=__List.append(cCounter('MCs <= 250 cc Displacement'))
__MCsGE1000Displacement=__List.append(cCounter('MCs >= 1000 cc Displacement'))
__MCsUnknownModelYear=__List.append(cCounter('MCs Unknown Model Year'))
__MCMeanAge=__List.append(cMean('MC Mean Age'))
__FatalitiesMCMeanAge=__List.append(cMean('Fatalities MC Mean Age'))
__FatalitiesHelmetProperMCMeanAge=__List.append(cMean('Fatalities with Helmet MC Mean Age'))
__FatalitiesHelmetNoneMCMeanAge=__List.append(cMean('Fatalities without Helmet MC Mean Age'))
__FARS.Tally()
__List.WriteCSV(YEAR,__States)

# Fin