package User;

use DBI;
use strict;
use EmailValid;
use Digest::MD5 qw( md5_hex );

# what value the evaulate functions return when the
# values is correct.
my $no_errors = "validated";



#constructor

sub new( $ )
{


     my $self  = {};



     $self->{userID}         = undef;
     $self->{userName}       = undef;
     $self->{password}       = undef;
     $self->{passwordHint}   = undef;
     $self->{passwordHintAnswer} = undef;
     $self->{userActive}     = undef;
     $self->{legalName}      = undef;
     $self->{scaName}        = undef;
     $self->{addressLine1}   = undef;
     $self->{addressLine2}   = undef;
     $self->{state}          = undef;
     $self->{country}        = undef;
     $self->{city}           = undef;
     $self->{zip}            = undef;
     $self->{areaCode}       = undef;
     $self->{firstThree}     = undef;
     $self->{lastFour}       = undef;
     $self->{extension}      = undef;
     $self->{emailAddress}   = undef;

     bless ($self);

     return $self;

}

# Loads the user account with information from the database
# and returns undefined if not found or user id if found.
#
# ARGS DB handle, UserID
#
# RETURNS UserID or undef if not found

sub load_user( $ )
{
   my $self = shift;

   my $dbh = $_[0];
   
   my $sqlQuery = "SELECT UserID,
                          UserName,
                          Password,
                          PasswordHint,
                          PasswordHintAnswer,
                          UserActive,
                          LegalName,
                          ScaName,
                          AddressLine1,
                          AddressLine2,
                          State,
                          Country,
                          City,
                          Zip,
                          AreaCode,
                          FirstThree,
                          LastFour,
                          Extension,
                          EmailAddress
                     FROM USERINFORMATION
                    WHERE UserID = \'$_[1]\'";

   my $query = $dbh->prepare( $sqlQuery );

	$query->execute() || die $dbh->errstr;

   my @userData = $query->fetchrow_array();

   
     $self->{user_id}            = $userData[0];
     $self->{user_name}          = $userData[1];
     $self->{password}           = $userData[2];
     $self->{password_hint}      = $userData[3];
     $self->{password_hint_answer} = $userData[4];
     $self->{user_active}        = $userData[5];
     $self->{legal_name}         = $userData[6];
     $self->{sca_name}           = $userData[7];
     $self->{address_line_1}     = $userData[8];
     $self->{address_line_2}     = $userData[9];
     $self->{state}              = $userData[10];
     $self->{country}            = $userData[11];
     $self->{city}               = $userData[12];
     $self->{zip}                = $userData[13];
     $self->{area_code}          = $userData[14];
     $self->{first_three}        = $userData[15];
     $self->{last_four}          = $userData[16];
     $self->{extension}          = $userData[17];
     $self->{email_address}      = $userData[18];

   return( $self->{userID} );

}


sub save_user()
{
   

}



###############################################################################
# VALIDATE AND UPDATE SUBROUTINES
#
# called by the main system this allows for a standardized 
# checking of variables for correctness
#
# ARGS    : VALUE TO BE VERIFIED
# RETURNS : ARRAY->( "$true_error_value" if error 
#                    "$false_error_value" if no error 
#                    AND
#                    HTML ERROR STRING
#

sub update_user_id( $ )
{
	my $self = shift;
	
	if( $_[0] eq "" )
	{
		return( &generate_form_entry_error_string( "blank" ) );
	} 
	elsif( length( $_[0] > 11 ) )
	{
		return( &generate_form_entry_error_string( "length" ) );	
	}
	elsif( $_[0] !~ /^[0-9]/  )  							  
	{
		return( &generate_form_entry_error_string( "0-9" ) );
	}
	else
	{
		$self->{user_id} = $_[0];
	
		return( $no_errors );	
	}
}

sub update_user_name( $ )
{
	my $self = shift;
	
	if( $_[0] eq "" )
	{
		return( &generate_form_entry_error_string( "blank" ) );
	} 
   elsif( length( $_[0] > 20 ) )
	{
		return( &generate_form_entry_error_string( "length" ) );	
	}
	elsif( $_[0] !~ /^[A-Za-z0-9]/  )    							  
	{
		return( &generate_form_entry_error_string( "A-Z a-z 0-9" );
	}
	else
	{
		$self->{user_name} = $_[0];
		
		return( $no_errors );
	}
}


sub update_password( $ )
{
	my $self = shift;
	
	if( $_[0] eq "" )
	{
		return( &generate_form_entry_error_string( "blank" ) );
	} 
	elsif( length( $_[0] > 20 ) )
	{
		return( &generate_form_entry_error_string( "length" ) );	
	}
	elsif( $_[0] !~ /^[A-Za-z0-9]/  )    							  
	{
		return( &generate_form_entry_error_string( "A-Z a-z 0-9" );
	}
	else
	{
		my $digest = md5_hex( $_[0] );
		
		$self->{password} = $digest;
	
		return( $no_errors );
	}
	
}

sub update_password_hint( $ )
{
	my $self = shift;
	
	if( $_[0] eq "" )
	{
		return( &generate_form_entry_error_string( "blank" ) );
	} 
	elsif( length( $_[0] > 100 ) )
	{
		return( &generate_form_entry_error_string( "length" ) );	
	}
	elsif( $_[0] !~ /^[A-Za-z0-9\'\.-]/  )    							  
	{
		return( &generate_form_entry_error_string( "A-Z a-z 0-9 \' . -" );
	}
	else
	{
			$self->{password_hint} = $_[0];
	
	      return( $no_errors );		
	}
}


sub update_password_hint_answer( $ )
{
	my $self = shift;
	
	if( $_[0] eq "" )
	{
		return( &generate_form_entry_error_string( "blank" ) );
	} 
	elsif( length( $_[0] > 100 ) )
	{
		return( &generate_form_entry_error_string( "length" ) );	
	}
	elsif( $_[0] !~ /^[A-Za-z0-9\'\.-]/  )    							  
	{
		return( &generate_form_entry_error_string( "A-Z a-z 0-9 \' . -" );
	}
	else
	{
			$self->{password_hint_answer} = $_[0];
	
			return( $no_errors );
	}
}


sub update_user_active( $ )
{
	my $self = shift;
	
	if( $_[0] eq "" )
	{
		return( &generate_form_entry_error_string( "blank" ) );
	} 
	elsif( length( $_[0] > 1 ) )
	{
		return( &generate_form_entry_error_string( "length" ) );	
	}
	elsif( $_[0] !~ /^[0|1]/  )    							  
	{
		return( &generate_form_entry_error_string( "0 or 1" );
	}
	else
	{
			$self->{user_active} = $_[0];
	
			return( $no_errors );		
			
	}
}

sub update_legal_name( $ )
{
	my $self = shift;
	
	if( $_[0] eq "" )
	{
		return( &generate_form_entry_error_string( "blank" ) );
	} 
	elsif( length( $_[0] > 100 ) )
	{
		return( &generate_form_entry_error_string( "length" ) );	
	}
	elsif( $_[0] !~ /^[A-Za-z0-9\'\.-]/  )    							  
	{
		return( &generate_form_entry_error_string( "A-Z a-z 0-9 \' . -" );
	}
	else
	{
			$self->{legal_name} = $_[0];
			
			return( $no_errors );
	}
}

sub update_sca_name( $ )
{
	my $self = shift;
	
	if( $_[0] eq "" )
	{
		return( &generate_form_entry_error_string( "blank" ) );
	} 
	elsif( length( $_[0] > 100 ) )
	{
		return( &generate_form_entry_error_string( "length" ) );	
	}
	elsif( $_[0] !~ /^[A-Za-z0-9\'\.-]/  )    							  
	{
		return( &generate_form_entry_error_string( "A-Z a-z 0-9 \' . -" );
	}
	else
	{
			$self->{sca_name} = $_[0];
			
			return( $no_errors );
	}
}

sub update_address_line_1( $ )
{
	my $self = shift;
	
	if( $_[0] eq "" )
	{
		return( &generate_form_entry_error_string( "blank" ) );
	} 
	elsif( length( $_[0] > 100 ) )
	{
		return( &generate_form_entry_error_string( "length" ) );	
	}
	elsif( $_[0] !~ /^[A-Za-z0-9\'\.-]/  )    							  
	{
		return( &generate_form_entry_error_string( "A-Z a-z 0-9 \' . -" );
	}
	else
	{
			$self->{address_line_1} = $_[0];
			
			return( $no_errors );
	}
}


sub update_address_line_2( $ )
{
	my $self = shift;
	
	if( $_[0] eq "" )
	{
		return( &generate_form_entry_error_string( "blank" ) );
	} 
	elsif( length( $_[0] > 100 ) )
	{
		return( &generate_form_entry_error_string( "length" ) );	
	}
	elsif( $_[0] !~ /^[A-Za-z0-9\'\.-]/  )    							  
	{
		return( &generate_form_entry_error_string( "A-Z a-z 0-9 \' . -" );
	}
	else
	{
			$self->{address_line_2} = $_[0];
			
			return( $no_errors );
	}
}


sub update_state( $ )
{
	my $self = shift;
	
	if( $_[0] eq "" )
	{
		return( &generate_form_entry_error_string( "blank" ) );
	} 
	elsif( length( $_[0] > 20 ) )
	{
		return( &generate_form_entry_error_string( "length" ) );	
	}
	elsif( $_[0] !~ /^[A-Za-z0-9\.-]/  )    							  
	{
		return( &generate_form_entry_error_string( "A-Z a-z 0-9. -" );
	}
	else
	{
			$self->{state} = $_[0];
			
			return( $no_errors );
	}
}


sub update_country( $ )
{
	my $self = shift;
	
	if( $_[0] eq "" )
	{
		return( &generate_form_entry_error_string( "blank" ) );
	} 
	elsif( length( $_[0] > 20 ) )
	{
		return( &generate_form_entry_error_string( "length" ) );	
	}
	elsif( $_[0] !~ /^[A-Za-z0-9\.-]/  )    							  
	{
		return( &generate_form_entry_error_string( "A-Z a-z . -" );
	}
	else
	{
			$self->{country} = $_[0];
	
			return( $no_errors );		
	}
}


sub update_city( $ )
{
	my $self = shift;
	
	if( $_[0] eq "" )
	{
		return( &generate_form_entry_error_string( "blank" ) );
	} 
	elsif( length( $_[0] > 30 ) )
	{
		return( &generate_form_entry_error_string( "length" ) );	
	}
	elsif( $_[0] !~ /^[A-Za-z0-9\'\.-]/  )    							  
	{
		return( &generate_form_entry_error_string( "A-Z a-z 0-9 \' . -" );
	}
	else
	{
	   $self->{city} = $_[0];
	
		return( $no_errors );		
	}
}

sub update_zip( $ )
{
	my $self = shift;
	
	if( $_[0] eq "" )
	{
		return( &generate_form_entry_error_string( "blank" ) );
	} 
	elsif( length( $_[0] > 11 ) )
	{
		return( &generate_form_entry_error_string( "length" ) );	
	}
	elsif( $_[0] !~ /^[A-Za-z0-9-]/  )    							  
	{
		return( &generate_form_entry_error_string( "A-Z a-z 0-9" );
	}
	else
	{
			$self->{zip} = $_[0];
	
			return( $no_errors );		
	}
}


sub update_area_code( $ )
{
	my $self = shift;
	
	if( $_[0] eq "" )
	{
		return( &generate_form_entry_error_string( "blank" ) );
	} 
	elsif( length( $_[0] > 3 ) )
	{
		return( &generate_form_entry_error_string( "length" ) );	
	}
	elsif( $_[0] !~ /^[0-9]/  )    							  
	{
		return( &generate_form_entry_error_string( "0-9" );
	}
	else
	{
		$self->{area_code} = $_[0];
	
		return( $no_errors );		
	}
}


sub update_first_three( $ )
{
	my $self = shift;
	
	if( $_[0] eq "" )
	{
		return( &generate_form_entry_error_string( "blank" ) );
	} 
	elsif( length( $_[0] > 3 ) )
	{
		return( &generate_form_entry_error_string( "length" ) );	
	}
	elsif( $_[0] !~ /^[0-9]/  )    							  
	{
		return( &generate_form_entry_error_string( "0-9" );
	}
	else
	{
		$self->{first_three} = $_[0];
	
		return( $no_errors );		
	}
}

sub update_last_four( $ )
{
	my $self = shift;
	
	if( $_[0] eq "" )
	{
		return( &generate_form_entry_error_string( "blank" ) );
	} 
	elsif( length( $_[0] > 4 ) )
	{
		return( &generate_form_entry_error_string( "length" ) );	
	}
	elsif( $_[0] !~ /^[0-9]/  )    							  
	{
		return( &generate_form_entry_error_string( "0-9" );
	}
	else
	{
		$self->{last_four} = $_[0];

		return( $no_errors );
	}
}


sub update_extension( $ )
{
	my $self = shift;
	
	if( $_[0] eq "" )
	{
		return( &generate_form_entry_error_string( "blank" ) );
	}
	elsif( $_[0] eq ""  )
	{
		$self->{extension} = $_[0];	
	} 
	elsif( length( $_[0] > 4 ) )
	{
		return( &generate_form_entry_error_string( "length" ) );	
	}
	elsif( $_[0] !~ /^[0-9]/  )    							  
	{
		return( &generate_form_entry_error_string( "0-9" );
	}
	else
	{
			$self->{extension} = $_[0];

			return( $no_errors );
	}
}


sub update_email_address( $ )
{
	my $self = shift;
	
	if( $_[0] eq "" )
	{
		return( &generate_form_entry_error_string( "blank" ) );
	} 
	elsif( length( $_[0] > 50 ) )
	{
		return( &generate_form_entry_error_string( "length" ) );	
	}
	elsif( $_[0] !~ /^[A-Za-z0-9\.\@]/  )    							  
	{
		return( &generate_form_entry_error_string( "A-Z a-z 0-9 . \@" );
	}
	elsif( $_[0] =~ /\s/ )
	{
   	return( &generate_form_entry_error_string( "A-Z a-z 0-9 . \@ No Spaces" );
	}
	elseif( !EmailValid->rfc822( $_[0] ) ) 
	{
   	return( &generate_form_entry_error_string( "A-Z a-z 0-9 . \@ No Spaces" );	
	}
	else
	{
		$self->{email_address} = $_[0];
	
		return( $no_errors );
	}

}

	
###############################################################################
# GENERATE SUBROUTINES
# 
# called by the main system this allows for a standardized
# production of form elements
# form elements should not be generated in main line code
# these methods should be called
#
# ARGS    : NONE
# RETURNS : HTML FORM FIELD
#
#



sub generate_user_ID 
{
	my $self = shift;
	
	return(  &generate_line_form_element( "text", "user_id" , $self->{user_id},
	                                      $self->{user_id} , "5" , "10" );
	
}

sub generate_user_name
{
	my $self = shift;
	
	return(  &generate_line_form_element( "text", "user_name" , $self->{user_name},
	                                      $self->{user_id} , "20" , "20" );
}  
   
sub generate_password
{
	my $self = shift;
	
	return(  "Passwords MD5 hasked for security" );
}

sub generate_password_hint
{
	my $self = shift;
	
	return(  &generate_line_form_element( "text", "password_hint" , $self->{password_hint},
	                                      $self->{password_hint} , "50" , "100" );
}
                                      
sub generate_password_hint_answer
{
	my $self = shift;
	
	return(  &generate_line_form_element( "text", "password_hint_answer" , $self->{password_hint_answer}, 
	                                      $self->{password_hint_answer} , "50" , "100" );		
}

sub generate_user_active
{
	my $self = shift;
	
	return(  &generate_line_form_element( "text", "user_active", $self->{user_active},
	                                      $self->{user_active} , "10" , "1" );		
}

sub generate_legal_name
{
	my $self = shift;
	
	return(  &generate_line_form_element( "text", "legal_name" , $self->{legal_name},
	                                      $self->{legal_name} , "50" , "100" );		
}

sub generate_sca_name
{
	my $self = shift;
	
	return(  &generate_line_form_element( "text", "sca_name" , $self->{sca_name},
	                                      $self->{sca_name} , "50" , "100" );		
}

sub generate_address_line_1
{
	my $self = shift;
	
	return(  &generate_line_form_element( "text", "address_line_1" , $self->{address_line_1}, 
	                                      $self->{address_line_1} , "50" , "100" );		
}

sub generate_address_line_2
{
	my $self = shift;
	
	return(  &generate_line_form_element( "text", "address_line_2" , $self->{address_line_2},
	                                      $self->{address_line_2} , "50" , "100" );		
}

sub generate_state
{
	my $self = shift;
	
	return(  &generate_line_form_element( "text", "state" , $self->{state},
	                                      $self->{city} , "20" , "20" );		
}

sub generate_country
{
	my $self = shift;
	
	return(  &generate_line_form_element( "text", "country" , $self->{country},
	                                      $self->{country} , "20" , "20" );		
}

sub generate_city
{
	my $self = shift;
	
	return(  &generate_line_form_element( "text", "city" , $self->{city},
	                                      $self->{country} , "20" , "30" );
}

sub generate_zip
{
	my $self = shift;
	
	return(  &generate_line_form_element( "text", "zip" , $self->{zip},
	                                      $self->{country} , "10" , "10" );		
}

sub generate_area_code
{
	my $self = shift;
	
	return(  &generate_line_form_element( "text", "area_code" , $self->{area_code},
	                                      $self->{area_code} , "3" , "3" );
	                                      		
}

sub generate_first_three
{
	my $self = shift;
	
	return(  &generate_line_form_element( "text", "first_three" , $self->{first_three},
	                                      $self->{first_three} , "3" , "3" );
	                                      		
}

sub generate_last_four
{
	my $self = shift;
	
	return(  &generate_line_form_element( "text", "last_four" , $self->{last_four},
	                                      $self->{last_four} , "4" , "4" );
	                                      		
}

sub generate_extension
{
	my $self = shift;
	
	return(  &generate_line_form_element( "text", "extension" , $self->{extension},
	                                      $self->{extension} , "4" , "4" );
	                                      		
}

sub generate_email_address
{
	my $self = shift;
	
	return(  &generate_line_form_element( "text", "email_address" , $self->{email_address},
	                                      $self->{email_address} , "30" , "50" );
	                                      		
}





# Creates the basic line form elements based on 
# passed data
# ARGS type, name, value, length, maxlength 
# RETURNS the HTML string for the form

sub generate_line_form_element( $ )
{

	my $form_element = "< INPUT TYPE=";
	
	if(    $_[0] eq "text" )
	{
		$form_element .= "\"text\"";
	}
	elsif( $_[0] eq "password" )
	{
		$form_element .= "\"password\"";
	}	
	elsif( $_[0] eq "hidden" )
	{
		$form_element .= "\"hidden\"";
	}		
	
	$form_element .= "NAME= \"$_[1]\"";
	
	$form_element .= "VALUE= \"$_[2]\"";
	
	$form_element .= "LENGTH= \"$_[3]\"";
	
	$form_element .= "MAXLENGTH= \"$_[4]\" >";
	
}
	
	
	
# creates the error response html codes
#
# ARGS:    allowed char string OR 
#          blank              
# RETURNS: html string
#

sub generate_form_entry_error_string( $ )
{
	if( $_[0] eq "blank" )
	{
		return( "<font face=\"Arial, Helvetica, sans-serif\" 
		         size=\"2\" color=\"red\">
               This field must be filled in
               <\/font>" );
   }
   else
   {
	   return( "<font face=\"Arial, Helvetica, sans-serif\" 
               size=\"2\" color=\"red\">
               Values may only contain ( $_[0] )<\/font>"); 
	}
	
}



1;