#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include "people.h"


float matchAlphaPercentage(char *object, char *target)
{
/* 
  (1) input: object string and target string
  (2) output: match percentage of object vs target
  (3) Both object and target strings are alphabetic strings in upper case.
      Legal charaters set is from 'A' to 'Z'.
  (4) This function does not concern about the letters order in both strings. 
      Only the occurences of letters are put into consideration for matching.
  (5) Formula:
      percentage = coefficient * numberOfHit / lengthOfTarget * 100.00
      ceofficient = lengthOfObject / lengthOfTarget; if larger lengthOfTarget
      or          = lengthOfTarget / lengthOfObject; otherwise
  (6) Examples:
        object 'AAA' vs target 'AAAA' = 0.75 * 3 / 4 * 100.0
        object 'ABCDEFG' vs target 'AXYZG' = 0.71 * 2 / 5 * 100.00
*/
  float percentage = 0.00;
  float coefficient = 0.00;
  int numberOfHit = 0;
  int i;
  int objectLetterSet[numberOfAlphabet] =
    {0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0, 0,0,0,0,0, 0};
  int targetLetterSet[numberOfAlphabet] =
    {0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0, 0,0,0,0,0, 0};
  float strlenObject = strlen(object);
  float strlenTarget = strlen(target);
  char *moreLetter;
  if ((strlenObject == 0) || (strlenTarget == 0))
    return(perfectMatch);
  coefficient = strlenObject / strlenTarget;
  if (coefficient > 1.00) 
    coefficient = 1.00 /  coefficient;
  moreLetter = object;
  while (*moreLetter)
    objectLetterSet[(*moreLetter++) - 'A']++;
  moreLetter = target;
  while (*moreLetter)
    targetLetterSet[(*moreLetter++) - 'A']++;
  for (i = 0; i < numberOfAlphabet; i++)
    if (objectLetterSet[i] <= targetLetterSet[i])
      numberOfHit += objectLetterSet[i];
    else  
      numberOfHit += targetLetterSet[i];
  percentage = numberOfHit / strlenTarget * coefficient * 100.00;
  return(percentage);  
}

float matchDigitPercentage(char *object, char *target)
{
/* 
  (1) input: object string and target string
  (2) output: match percentage of object vs target
  (3) Both object and target strings are numeric strings.
      Legal charaters set is from '0' to '9'.
  (4) This function does not concern about the letters order in both strings. 
      Only the occurences of letters are put into consideration for matching.
  (5) Formula:
      percentage = coefficient * numberOfHit / lengthOfTarget * 100.00
      ceofficient = lengthOfObject / lengthOfTarget; if larger lengthOfTarget
      or          = lengthOfTarget / lengthOfObject; otherwise
  (6) Examples:
        object '000' vs target '0000' = 0.75 * 3 / 4 * 100.0
        object '0123456' vs target '69990' = 0.71 * 2 / 5 * 100.00
*/
  float percentage = 0.00;
  float coefficient = 0.00;
  int numberOfHit = 0;
  int i;
  int objectLetterSet[numberOfNumeric] = {0,0,0,0,0, 0,0,0,0,0};
  int targetLetterSet[numberOfNumeric] = {0,0,0,0,0, 0,0,0,0,0};
  float strlenObject = strlen(object);
  float strlenTarget = strlen(target);
  char *moreLetter;
  if ((strlenObject == 0) || (strlenTarget == 0))
    return(perfectMatch);
  coefficient = strlenObject / strlenTarget;
  if (coefficient > 1.00) 
    coefficient = 1.00 /  coefficient;
  moreLetter = object;
  while (*moreLetter)
    objectLetterSet[(*moreLetter++) - '0']++;
  moreLetter = target;
  while (*moreLetter)
    targetLetterSet[(*moreLetter++) - '0']++;
  for (i = 0; i < numberOfNumeric; i++)
    if (objectLetterSet[i] <= targetLetterSet[i])
      numberOfHit += objectLetterSet[i];
    else  
      numberOfHit += targetLetterSet[i];
  percentage = numberOfHit / strlenTarget * coefficient * 100.00;
  return(percentage);  
}



char *soundex(char *string)
{
  static char soundexString[soundexLength+1];
  static char map[] = "01230120022455012623010202";
  register char uppercase, mapped, prevChar = '0';
  register int index;
  strcpy(soundexString,"Z0000");
  for (index = 0; *string && index < soundexLength; string++)
    if (isalpha(*string))
    {
      uppercase = toupper(*string);
      mapped = map[uppercase-'A'];
      if (index == 0 || (mapped != '0' && mapped != prevChar))
      {
        soundexString[index] = index ? mapped : uppercase;
        index++;
      }
      prevChar = mapped;
    }
  return(soundexString);
}

boolean equalString(register char *object, register char *target)
{
  /* Input two strings, return TURE,    */
  /* if both strings are equal;         */
  /* return FALSE, otherwise.           */
/*
  if (DEBUG)
    printf("object = %s vs target = %s\n", object, target);
*/
  while(*object == *target++)
    if (*object++ == '\0')
      return(TRUE);
  return(FALSE);
}


boolean equalSoundex(register char *object, register char *target)
{
  /* Input two strings, return TURE,    */
  /* if soundex of both strings are     */
  /* equal; return FALSE, otherwise.    */
  char objectSoundex[soundexLength+1];
  char targetSoundex[soundexLength+1];
  strcpy(objectSoundex, soundex(object));
  strcpy(targetSoundex, soundex(target));
/*
  if (DEBUG)
    printf("soundex(%s) = %s vs soundex(%s) = %s\n",
      object, objectSoundex, target, targetSoundex);
*/
  if (equalString(objectSoundex, targetSoundex))
    return(TRUE);
  else
    return(FALSE);
}

boolean equalDOB(register char *dob1, register char *dob2)
{
  
/*
  if (DEBUG)
    printf("birthday = %s vs birthday= %s\n", dob1, dob2);
*/
  if (equalString(dob1, dob2))
    return(TRUE);
  else
    return(FALSE);
}

boolean equalSSN(register char *ssn1, register char *ssn2)
{
  
/*
  if (DEBUG)
    printf("ssn = %s vs ssn= %s\n", ssn1, ssn2);
*/
  if (equalString(ssn1, ssn2))
    return(TRUE);
  else
    return(FALSE);
}