oak-delphi 0.0.11

unit DelphiTestFile;

interface

uses
  System.SysUtils, System.Classes, System.Generics.Collections,
  System.DateUtils, System.Math, System.StrUtils, System.IOUtils,
  Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls,
  Vcl.ExtCtrls, Vcl.ComCtrls, Vcl.Menus, Vcl.ToolWin, Vcl.ActnList,
  Vcl.ImgList, Vcl.Grids, Vcl.DBGrids, Vcl.DBCtrls, Vcl.Mask,
  Data.DB, Data.Win.ADODB, FireDAC.Stan.Intf, FireDAC.Stan.Option,
  FireDAC.Stan.Error, FireDAC.UI.Intf, FireDAC.Phys.Intf, FireDAC.Stan.Def,
  FireDAC.Stan.Pool, FireDAC.Stan.Async, FireDAC.Phys, FireDAC.Phys.MSAcc,
  FireDAC.Phys.MSAccDef, FireDAC.VCLUI.Wait, FireDAC.Stan.Param,
  FireDAC.DatS, FireDAC.DApt.Intf, FireDAC.DApt, FireDAC.Comp.DataSet,
  FireDAC.Comp.Client;

type
  // Basic types and enumerations
  TUserRole = (urGuest, urUser, urAdmin, urSupervisor);
  TAccessLevel = (alNone = 0, alRead = 1, alWrite = 2, alFull = 3);
  TStatusCode = 100..599;
  TCustomerID = type Integer;
  TPercentage = 0..100;
  TFileName = type string;
  TEmailAddress = type string;

  // Record types
  TPerson = record
    FirstName: string;
    LastName: string;
    BirthDate: TDateTime;
    Age: Integer;
    Email: TEmailAddress;
    Active: Boolean;
    Role: TUserRole;
    AccessLevel: TAccessLevel;
  end;

  TAddress = record
    Street: string;
    City: string;
    State: string;
    ZipCode: string;
    Country: string;
    procedure Clear;
    function FullAddress: string;
  end;

  // Class types
  TCustomer = class(TObject)
  private
    FID: TCustomerID;
    FName: string;
    FEmail: string;
    FPhone: string;
    FAddress: TAddress;
    FBalance: Currency;
    FCreated: TDateTime;
    FModified: TDateTime;
    FActive: Boolean;
    FDiscount: TPercentage;
    FTags: TStringList;
    procedure SetBalance(const Value: Currency);
    procedure SetEmail(const Value: string);
    function GetFullName: string;
  protected
    procedure DoModify; virtual;
    function ValidateEmail(const Email: string): Boolean;
  public
    constructor Create;
    destructor Destroy; override;
    procedure Assign(Source: TCustomer); virtual;
    function Clone: TCustomer;
    procedure LoadFromDataset(Dataset: TDataSet);
    procedure SaveToDataset(Dataset: TDataSet);
    function CalculateDiscount(Amount: Currency): Currency;
    class function GetCustomerByID(ID: TCustomerID): TCustomer; static;
    property ID: TCustomerID read FID write FID;
    property Name: string read FName write FName;
    property Email: string read FEmail write SetEmail;
    property Phone: string read FPhone write FPhone;
    property Address: TAddress read FAddress write FAddress;
    property Balance: Currency read FBalance write SetBalance;
    property Created: TDateTime read FCreated write FCreated;
    property Modified: TDateTime read FModified;
    property Active: Boolean read FActive write FActive;
    property Discount: TPercentage read FDiscount write FDiscount;
    property FullName: string read GetFullName;
    property Tags: TStringList read FTags;
  end;

  // Generic class
  TGenericList<T> = class(TObject)
  private
    FItems: array of T;
    FCount: Integer;
    FCapacity: Integer;
    procedure Grow;
    function GetItem(Index: Integer): T;
    procedure SetItem(Index: Integer; const Value: T);
  public
    constructor Create;
    destructor Destroy; override;
    procedure Add(const Item: T);
    procedure Insert(Index: Integer; const Item: T);
    procedure Delete(Index: Integer);
    function Remove(const Item: T): Integer;
    function IndexOf(const Item: T): Integer;
    procedure Clear;
    procedure Sort(Compare: TComparer<T>); overload;
    procedure Sort; overload;
    property Count: Integer read FCount;
    property Items[Index: Integer]: T read GetItem write SetItem; default;
    property Capacity: Integer read FCapacity write FCapacity;
  end;

  // Interface definition
  ICustomerService = interface(IInterface)
    ['{B8F4D4E0-7A3C-4B9E-9F2D-1A5C7E9B8D3F}']
    function GetCustomer(ID: TCustomerID): TCustomer;
    procedure SaveCustomer(Customer: TCustomer);
    procedure DeleteCustomer(ID: TCustomerID);
    function GetAllCustomers: TArray<TCustomer>;
    function FindCustomers(const Filter: string): TArray<TCustomer>;
    function GetCustomerCount: Integer;
  end;

  // Class implementing interface
  TCustomerService = class(TInterfacedObject, ICustomerService)
  private
    FConnection: TFDConnection;
    FQuery: TFDQuery;
    procedure PrepareConnection;
    procedure ValidateCustomer(Customer: TCustomer);
  public
    constructor Create;
    destructor Destroy; override;
    function GetCustomer(ID: TCustomerID): TCustomer;
    procedure SaveCustomer(Customer: TCustomer);
    procedure DeleteCustomer(ID: TCustomerID);
    function GetAllCustomers: TArray<TCustomer>;
    function FindCustomers(const Filter: string): TArray<TCustomer>;
    function GetCustomerCount: Integer;
  end;

  // Helper class with class methods and class variables
  TMathHelper = class
  private
    class var FPI: Double;
    class var FEpsilon: Double;
    class constructor Create;
  public
    class function Factorial(N: Integer): Int64;
    class function Power(Base, Exponent: Double): Double;
    class function IsPrime(Number: Integer): Boolean;
    class function Fibonacci(N: Integer): Int64;
    class function GCD(A, B: Integer): Integer;
    class function LCM(A, B: Integer): Integer;
    class property PI: Double read FPI;
    class property Epsilon: Double read FEpsilon;
  end;

  // Form class
  TMainForm = class(TForm)
    MainMenu: TMainMenu;
    StatusBar: TStatusBar;
    ToolBar: TToolBar;
    ActionList: TActionList;
    ImageList: TImageList;
    PageControl: TPageControl;
    CustomerTab: TTabSheet;
    ReportTab: TTabSheet;
    CustomerGrid: TDBGrid;
    CustomerNavigator: TDBNavigator;
    FilterEdit: TEdit;
    FilterLabel: TLabel;
    SearchButton: TButton;
    ClearButton: TButton;
    ExportButton: TButton;
    PrintButton: TButton;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure SearchButtonClick(Sender: TObject);
    procedure ClearButtonClick(Sender: TObject);
    procedure ExportButtonClick(Sender: TObject);
    procedure PrintButtonClick(Sender: TObject);
    procedure FilterEditChange(Sender: TObject);
  private
    FCustomerService: ICustomerService;
    FCurrentCustomer: TCustomer;
    FFilterText: string;
    procedure InitializeComponents;
    procedure SetupDatabase;
    procedure LoadCustomers;
    procedure UpdateStatusBar;
    procedure ShowCustomerDetails(Customer: TCustomer);
    function ValidateForm: Boolean;
  protected
    procedure DoShow; override;
    procedure DoHide; override;
  public
    property CustomerService: ICustomerService read FCustomerService;
    property CurrentCustomer: TCustomer read FCurrentCustomer;
  end;

  // Thread class
  TBackgroundWorker = class(TThread)
  private
    FProgress: Integer;
    FMessage: string;
    FOnProgress: TNotifyEvent;
    FOnMessage: TNotifyEvent;
    procedure SetProgress(Value: Integer);
    procedure SetMessage(const Value: string);
  protected
    procedure Execute; override;
    procedure DoProgress;
    procedure DoMessage;
  public
    constructor Create(CreateSuspended: Boolean);
    property Progress: Integer read FProgress write SetProgress;
    property Message: string read FMessage write SetMessage;
    property OnProgress: TNotifyEvent read FOnProgress write FOnProgress;
    property OnMessage: TNotifyEvent read FOnMessage write FOnMessage;
  end;

  // Exception class
  ECustomerException = class(Exception)
  private
    FErrorCode: Integer;
    FCustomerID: TCustomerID;
  public
    constructor Create(const Msg: string; ErrorCode: Integer; CustomerID: TCustomerID);
    property ErrorCode: Integer read FErrorCode;
    property CustomerID: TCustomerID read FCustomerID;
  end;

  // Set type
  TCharSet = set of Char;
  TIntSet = set of 1..100;
  TDaySet = set of (Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday);

  // Array types
  TIntArray = array of Integer;
  TMatrix = array of array of Double;
  TCustomerArray = array of TCustomer;
  TFixedArray = array[1..10] of string;
  TMultiDimArray = array[1..5, 1..10] of Integer;

  // Pointer types
  PInteger = ^Integer;
  PCustomer = ^TCustomer;
  PPerson = ^TPerson;

  // Procedural types
  TNotifyInt = procedure(Value: Integer) of object;
  TCompareFunc = function(const A, B: string): Integer;
  TMathOperation = function(X, Y: Double): Double;
  TFilterFunc<T> = function(const Item: T): Boolean;

  // Const section
const
  APP_NAME = 'Delphi Test Application';
  VERSION = '1.0.0';
  MAX_CUSTOMERS = 10000;
  DEFAULT_DISCOUNT = 0.05;
  COMPANY_NAME = 'Test Company Inc.';
  COPYRIGHT_YEAR = 2024;
  PI_VALUE = 3.141592653589793;
  E_VALUE = 2.718281828459045;

  // Resource string
resourcestring
  SWelcomeMessage = 'Welcome to %s version %s';
  SErrorLoadingData = 'Error loading data: %s';
  SConfirmDelete = 'Are you sure you want to delete this customer?';
  SFileNotFound = 'File "%s" not found';
  SInvalidEmail = 'Invalid email address: %s';
  SSuccessMessage = 'Operation completed successfully';

var
  GlobalCustomerList: TGenericList<TCustomer>;
  GlobalSettings: TStringList;
  ApplicationPath: string;
  IsInitialized: Boolean = False;

implementation

{$R *.dfm}

{ TAddress }

procedure TAddress.Clear;
begin
  Street := '';
  City := '';
  State := '';
  ZipCode := '';
  Country := '';
end;

function TAddress.FullAddress: string;
begin
  Result := Format('%s, %s, %s %s, %s', [Street, City, State, ZipCode, Country]);
end;

{ TCustomer }

constructor TCustomer.Create;
begin
  inherited;
  FTags := TStringList.Create;
  FCreated := Now;
  FModified := Now;
  FActive := True;
  FDiscount := DEFAULT_DISCOUNT;
end;

destructor TCustomer.Destroy;
begin
  FTags.Free;
  inherited;
end;

procedure TCustomer.Assign(Source: TCustomer);
begin
  if Assigned(Source) then
  begin
    FID := Source.FID;
    FName := Source.FName;
    FEmail := Source.FEmail;
    FPhone := Source.FPhone;
    FAddress := Source.FAddress;
    FBalance := Source.FBalance;
    FCreated := Source.FCreated;
    FModified := Source.FModified;
    FActive := Source.FActive;
    FDiscount := Source.FDiscount;
    FTags.Assign(Source.FTags);
  end;
end;

function TCustomer.Clone: TCustomer;
begin
  Result := TCustomer.Create;
  Result.Assign(Self);
end;

procedure TCustomer.SetBalance(const Value: Currency);
begin
  if FBalance <> Value then
  begin
    FBalance := Value;
    DoModify;
  end;
end;

procedure TCustomer.SetEmail(const Value: string);
begin
  if FEmail <> Value then
  begin
    if ValidateEmail(Value) then
    begin
      FEmail := Value;
      DoModify;
    end
    else
      raise ECustomerException.CreateFmt(SInvalidEmail, [Value], 1001, FID);
  end;
end;

function TCustomer.GetFullName: string;
begin
  Result := Format('%s %s', [FName, FEmail]);
end;

procedure TCustomer.DoModify;
begin
  FModified := Now;
end;

function TCustomer.ValidateEmail(const Email: string): Boolean;
var
  Regex: TPerlRegEx;
begin
  Regex := TPerlRegEx.Create;
  try
    Regex.RegEx := '^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$';
    Regex.Subject := Email;
    Result := Regex.Match;
  finally
    Regex.Free;
  end;
end;

procedure TCustomer.LoadFromDataset(Dataset: TDataSet);
begin
  if Assigned(Dataset) and not Dataset.IsEmpty then
  begin
    FID := Dataset.FieldByName('ID').AsInteger;
    FName := Dataset.FieldByName('Name').AsString;
    FEmail := Dataset.FieldByName('Email').AsString;
    FPhone := Dataset.FieldByName('Phone').AsString;
    FAddress.Street := Dataset.FieldByName('Street').AsString;
    FAddress.City := Dataset.FieldByName('City').AsString;
    FAddress.State := Dataset.FieldByName('State').AsString;
    FAddress.ZipCode := Dataset.FieldByName('ZipCode').AsString;
    FAddress.Country := Dataset.FieldByName('Country').AsString;
    FBalance := Dataset.FieldByName('Balance').AsCurrency;
    FCreated := Dataset.FieldByName('Created').AsDateTime;
    FModified := Dataset.FieldByName('Modified').AsDateTime;
    FActive := Dataset.FieldByName('Active').AsBoolean;
    FDiscount := Dataset.FieldByName('Discount').AsFloat;
    FTags.CommaText := Dataset.FieldByName('Tags').AsString;
  end;
end;

procedure TCustomer.SaveToDataset(Dataset: TDataSet);
begin
  if Assigned(Dataset) then
  begin
    Dataset.FieldByName('ID').AsInteger := FID;
    Dataset.FieldByName('Name').AsString := FName;
    Dataset.FieldByName('Email').AsString := FEmail;
    Dataset.FieldByName('Phone').AsString := FPhone;
    Dataset.FieldByName('Street').AsString := FAddress.Street;
    Dataset.FieldByName('City').AsString := FAddress.City;
    Dataset.FieldByName('State').AsString := FAddress.State;
    Dataset.FieldByName('ZipCode').AsString := FAddress.ZipCode;
    Dataset.FieldByName('Country').AsString := FAddress.Country;
    Dataset.FieldByName('Balance').AsCurrency := FBalance;
    Dataset.FieldByName('Created').AsDateTime := FCreated;
    Dataset.FieldByName('Modified').AsDateTime := FModified;
    Dataset.FieldByName('Active').AsBoolean := FActive;
    Dataset.FieldByName('Discount').AsFloat := FDiscount;
    Dataset.FieldByName('Tags').AsString := FTags.CommaText;
  end;
end;

function TCustomer.CalculateDiscount(Amount: Currency): Currency;
begin
  Result := Amount * (1 - FDiscount);
end;

class function TCustomer.GetCustomerByID(ID: TCustomerID): TCustomer;
var
  Service: ICustomerService;
begin
  Service := TCustomerService.Create;
  Result := Service.GetCustomer(ID);
end;

{ TGenericList<T> }

constructor TGenericList<T>.Create;
begin
  inherited;
  FCount := 0;
  FCapacity := 16;
  SetLength(FItems, FCapacity);
end;

destructor TGenericList<T>.Destroy;
begin
  SetLength(FItems, 0);
  inherited;
end;

procedure TGenericList<T>.Add(const Item: T);
begin
  if FCount = FCapacity then
    Grow;
  FItems[FCount] := Item;
  Inc(FCount);
end;

procedure TGenericList<T>.Insert(Index: Integer; const Item: T);
var
  I: Integer;
begin
  if (Index < 0) or (Index > FCount) then
    raise EListError.Create('Index out of bounds');
    
  if FCount = FCapacity then
    Grow;
    
  for I := FCount downto Index + 1 do
    FItems[I] := FItems[I - 1];
    
  FItems[Index] := Item;
  Inc(FCount);
end;

procedure TGenericList<T>.Delete(Index: Integer);
var
  I: Integer;
begin
  if (Index < 0) or (Index >= FCount) then
    raise EListError.Create('Index out of bounds');
    
  for I := Index to FCount - 2 do
    FItems[I] := FItems[I + 1];
    
  Dec(FCount);
end;

function TGenericList<T>.Remove(const Item: T): Integer;
begin
  Result := IndexOf(Item);
  if Result >= 0 then
    Delete(Result);
end;

function TGenericList<T>.IndexOf(const Item: T): Integer;
var
  I: Integer;
  Comparer: IEqualityComparer<T>;
begin
  Comparer := TEqualityComparer<T>.Default;
  for I := 0 to FCount - 1 do
    if Comparer.Equals(FItems[I], Item) then
      Exit(I);
  Result := -1;
end;

procedure TGenericList<T>.Clear;
begin
  FCount := 0;
end;

procedure TGenericList<T>.Sort(Compare: TComparer<T>);
var
  Temp: T;
  I, J: Integer;
begin
  for I := 0 to FCount - 2 do
    for J := I + 1 to FCount - 1 do
      if Compare.Compare(FItems[I], FItems[J]) > 0 then
      begin
        Temp := FItems[I];
        FItems[I] := FItems[J];
        FItems[J] := Temp;
      end;
end;

procedure TGenericList<T>.Sort;
begin
  Sort(TComparer<T>.Default);
end;

procedure TGenericList<T>.Grow;
begin
  FCapacity := FCapacity * 2;
  SetLength(FItems, FCapacity);
end;

function TGenericList<T>.GetItem(Index: Integer): T;
begin
  if (Index < 0) or (Index >= FCount) then
    raise EListError.Create('Index out of bounds');
  Result := FItems[Index];
end;

procedure TGenericList<T>.SetItem(Index: Integer; const Value: T);
begin
  if (Index < 0) or (Index >= FCount) then
    raise EListError.Create('Index out of bounds');
  FItems[Index] := Value;
end;

{ TCustomerService }

constructor TCustomerService.Create;
begin
  inherited;
  PrepareConnection;
end;

destructor TCustomerService.Destroy;
begin
  FQuery.Free;
  FConnection.Free;
  inherited;
end;

procedure TCustomerService.PrepareConnection;
begin
  FConnection := TFDConnection.Create(nil);
  FQuery := TFDQuery.Create(nil);
  FQuery.Connection := FConnection;
  
  // Configure connection
  FConnection.Params.Values['DriverID'] := 'SQLite';
  FConnection.Params.Values['Database'] := 'customers.db';
  FConnection.LoginPrompt := False;
  
  try
    FConnection.Connected := True;
  except
    on E: Exception do
      raise ECustomerException.CreateFmt('Database connection failed: %s', [E.Message], 2001, 0);
  end;
end;

function TCustomerService.GetCustomer(ID: TCustomerID): TCustomer;
begin
  FQuery.SQL.Text := 'SELECT * FROM Customers WHERE ID = :ID';
  FQuery.ParamByName('ID').AsInteger := ID;
  FQuery.Open;
  
  try
    if not FQuery.IsEmpty then
    begin
      Result := TCustomer.Create;
      Result.LoadFromDataset(FQuery);
    end
    else
      Result := nil;
  finally
    FQuery.Close;
  end;
end;

procedure TCustomerService.SaveCustomer(Customer: TCustomer);
begin
  ValidateCustomer(Customer);
  
  if Customer.ID = 0 then
  begin
    // Insert new customer
    FQuery.SQL.Text := 
      'INSERT INTO Customers (Name, Email, Phone, Street, City, State, ZipCode, Country, ' +
      'Balance, Created, Modified, Active, Discount, Tags) VALUES ' +
      '(:Name, :Email, :Phone, :Street, :City, :State, :ZipCode, :Country, ' +
      ':Balance, :Created, :Modified, :Active, :Discount, :Tags)';
  end
  else
  begin
    // Update existing customer
    FQuery.SQL.Text := 
      'UPDATE Customers SET Name = :Name, Email = :Email, Phone = :Phone, ' +
      'Street = :Street, City = :City, State = :State, ZipCode = :ZipCode, ' +
      'Country = :Country, Balance = :Balance, Modified = :Modified, ' +
      'Active = :Active, Discount = :Discount, Tags = :Tags ' +
      'WHERE ID = :ID';
    FQuery.ParamByName('ID').AsInteger := Customer.ID;
  end;
  
  Customer.SaveToDataset(FQuery);
  FQuery.ExecSQL;
end;

procedure TCustomerService.DeleteCustomer(ID: TCustomerID);
begin
  FQuery.SQL.Text := 'DELETE FROM Customers WHERE ID = :ID';
  FQuery.ParamByName('ID').AsInteger := ID;
  FQuery.ExecSQL;
  
  if FQuery.RowsAffected = 0 then
    raise ECustomerException.Create('Customer not found', 2002, ID);
end;

function TCustomerService.GetAllCustomers: TArray<TCustomer>;
var
  Customer: TCustomer;
begin
  FQuery.SQL.Text := 'SELECT * FROM Customers ORDER BY Name';
  FQuery.Open;
  
  try
    SetLength(Result, FQuery.RecordCount);
    var I := 0;
    while not FQuery.Eof do
    begin
      Customer := TCustomer.Create;
      Customer.LoadFromDataset(FQuery);
      Result[I] := Customer;
      Inc(I);
      FQuery.Next;
    end;
  finally
    FQuery.Close;
  end;
end;

function TCustomerService.FindCustomers(const Filter: string): TArray<TCustomer>;
var
  Customer: TCustomer;
  FilterSQL: string;
begin
  FilterSQL := 'SELECT * FROM Customers WHERE Name LIKE :Filter OR Email LIKE :Filter ORDER BY Name';
  FQuery.SQL.Text := FilterSQL;
  FQuery.ParamByName('Filter').AsString := '%' + Filter + '%';
  FQuery.Open;
  
  try
    SetLength(Result, FQuery.RecordCount);
    var I := 0;
    while not FQuery.Eof do
    begin
      Customer := TCustomer.Create;
      Customer.LoadFromDataset(FQuery);
      Result[I] := Customer;
      Inc(I);
      FQuery.Next;
    end;
  finally
    FQuery.Close;
  end;
end;

function TCustomerService.GetCustomerCount: Integer;
begin
  FQuery.SQL.Text := 'SELECT COUNT(*) FROM Customers';
  FQuery.Open;
  
  try
    Result := FQuery.Fields[0].AsInteger;
  finally
    FQuery.Close;
  end;
end;

procedure TCustomerService.ValidateCustomer(Customer: TCustomer);
begin
  if Customer.Name = '' then
    raise ECustomerException.Create('Customer name is required', 2003, Customer.ID);
    
  if not Customer.ValidateEmail(Customer.Email) then
    raise ECustomerException.CreateFmt(SInvalidEmail, [Customer.Email], 2004, Customer.ID);
    
  if Customer.Balance < 0 then
    raise ECustomerException.Create('Customer balance cannot be negative', 2005, Customer.ID);
end;

{ TMathHelper }

class constructor TMathHelper.Create;
begin
  FPI := System.PI;
  FEpsilon := 1e-10;
end;

class function TMathHelper.Factorial(N: Integer): Int64;
var
  I: Integer;
begin
  if N < 0 then
    raise EMathError.Create('Factorial is not defined for negative numbers');
    
  Result := 1;
  for I := 2 to N do
    Result := Result * I;
end;

class function TMathHelper.Power(Base, Exponent: Double): Double;
begin
  if (Base = 0) and (Exponent <= 0) then
    raise EMathError.Create('Invalid power operation');
    
  Result := System.Math.Power(Base, Exponent);
end;

class function TMathHelper.IsPrime(Number: Integer): Boolean;
var
  I: Integer;
begin
  if Number <= 1 then
    Exit(False);
    
  if Number <= 3 then
    Exit(True);
    
  if (Number mod 2 = 0) or (Number mod 3 = 0) then
    Exit(False);
    
  I := 5;
  while I * I <= Number do
  begin
    if (Number mod I = 0) or (Number mod (I + 2) = 0) then
      Exit(False);
    Inc(I, 6);
  end;
  
  Result := True;
end;

class function TMathHelper.Fibonacci(N: Integer): Int64;
var
  A, B, Temp: Int64;
  I: Integer;
begin
  if N <= 0 then
    Exit(0);
    
  if N = 1 then
    Exit(1);
    
  A := 0;
  B := 1;
  
  for I := 2 to N do
  begin
    Temp := A + B;
    A := B;
    B := Temp;
  end;
  
  Result := B;
end;

class function TMathHelper.GCD(A, B: Integer): Integer;
var
  Temp: Integer;
begin
  A := Abs(A);
  B := Abs(B);
  
  while B <> 0 do
  begin
    Temp := B;
    B := A mod B;
    A := Temp;
  end;
  
  Result := A;
end;

class function TMathHelper.LCM(A, B: Integer): Integer;
begin
  if (A = 0) or (B = 0) then
    Result := 0
  else
    Result := Abs(A * B) div GCD(A, B);
end;

{ TBackgroundWorker }

constructor TBackgroundWorker.Create(CreateSuspended: Boolean);
begin
  inherited Create(CreateSuspended);
  FProgress := 0;
  FMessage := '';
  FreeOnTerminate := True;
end;

procedure TBackgroundWorker.Execute;
var
  I: Integer;
begin
  try
    for I := 1 to 100 do
    begin
      if Terminated then
        Break;
        
      Sleep(50); // Simulate work
      Progress := I;
      Message := Format('Processing item %d of 100', [I]);
    end;
    
    Message := 'Background work completed';
  except
    on E: Exception do
    begin
      Message := 'Error: ' + E.Message;
    end;
  end;
end;

procedure TBackgroundWorker.SetProgress(Value: Integer);
begin
  if FProgress <> Value then
  begin
    FProgress := Value;
    Synchronize(DoProgress);
  end;
end;

procedure TBackgroundWorker.SetMessage(const Value: string);
begin
  if FMessage <> Value then
  begin
    FMessage := Value;
    Synchronize(DoMessage);
  end;
end;

procedure TBackgroundWorker.DoProgress;
begin
  if Assigned(FOnProgress) then
    FOnProgress(Self);
end;

procedure TBackgroundWorker.DoMessage;
begin
  if Assigned(FOnMessage) then
    FOnMessage(Self);
end;

{ ECustomerException }

constructor ECustomerException.Create(const Msg: string; ErrorCode: Integer; CustomerID: TCustomerID);
begin
  inherited Create(Msg);
  FErrorCode := ErrorCode;
  FCustomerID := CustomerID;
end;

{ TMainForm }

procedure TMainForm.FormCreate(Sender: TObject);
begin
  InitializeComponents;
  SetupDatabase;
  LoadCustomers;
  UpdateStatusBar;
end;

procedure TMainForm.FormDestroy(Sender: TObject);
begin
  if Assigned(FCurrentCustomer) then
    FCurrentCustomer.Free;
end;

procedure TMainForm.InitializeComponents;
begin
  Caption := Format('%s - %s', [APP_NAME, VERSION]);
  
  // Initialize form components
  FilterEdit.Text := '';
  FilterLabel.Caption := 'Filter:';
  SearchButton.Caption := 'Search';
  ClearButton.Caption := 'Clear';
  ExportButton.Caption := 'Export';
  PrintButton.Caption := 'Print';
  
  // Setup grid
  CustomerGrid.Options := CustomerGrid.Options + [dgRowSelect, dgAlwaysShowSelection];
  CustomerGrid.Align := alClient;
end;

procedure TMainForm.SetupDatabase;
begin
  FCustomerService := TCustomerService.Create;
end;

procedure TMainForm.LoadCustomers;
var
  Customers: TArray<TCustomer>;
  I: Integer;
begin
  try
    if FFilterText <> '' then
      Customers := FCustomerService.FindCustomers(FFilterText)
    else
      Customers := FCustomerService.GetAllCustomers;
      
    // Load customers into grid or other UI components
    // This is a simplified version - in real app would use data binding
    for I := 0 to High(Customers) do
    begin
      // Add to grid or list
      if Assigned(Customers[I]) then
        Customers[I].Free;
    end;
  except
    on E: Exception do
      MessageDlg(Format(SErrorLoadingData, [E.Message]), mtError, [mbOK], 0);
  end;
end;

procedure TMainForm.UpdateStatusBar;
begin
  StatusBar.Panels[0].Text := Format('Total customers: %d', [FCustomerService.GetCustomerCount]);
  StatusBar.Panels[1].Text := Format('Filter: %s', [FFilterText]);
  StatusBar.Panels[2].Text := Format('Date: %s', [FormatDateTime('yyyy-mm-dd', Now)]);
end;

procedure TMainForm.SearchButtonClick(Sender: TObject);
begin
  FFilterText := FilterEdit.Text;
  LoadCustomers;
  UpdateStatusBar;
end;

procedure TMainForm.ClearButtonClick(Sender: TObject);
begin
  FilterEdit.Text := '';
  FFilterText := '';
  LoadCustomers;
  UpdateStatusBar;
end;

procedure TMainForm.ExportButtonClick(Sender: TObject);
begin
  // Export customers to CSV or other format
  // Implementation would go here
  ShowMessage('Export functionality would be implemented here');
end;

procedure TMainForm.PrintButtonClick(Sender: TObject);
begin
  // Print customer list
  // Implementation would go here
  ShowMessage('Print functionality would be implemented here');
end;

procedure TMainForm.FilterEditChange(Sender: TObject);
begin
  // Auto-search as user types (with debouncing)
  // Implementation would include timer-based debouncing
end;

procedure TMainForm.DoShow;
begin
  inherited;
  ShowMessage(Format(SWelcomeMessage, [APP_NAME, VERSION]));
end;

procedure TMainForm.DoHide;
begin
  inherited;
  // Cleanup when form is hidden
end;

procedure TMainForm.ShowCustomerDetails(Customer: TCustomer);
begin
  if Assigned(Customer) then
  begin
    if Assigned(FCurrentCustomer) then
      FCurrentCustomer.Free;
      
    FCurrentCustomer := Customer.Clone;
    // Update UI with customer details
    // Implementation would go here
  end;
end;

function TMainForm.ValidateForm: Boolean;
begin
  Result := True;
  // Form validation logic would go here
end;

initialization
  GlobalCustomerList := TGenericList<TCustomer>.Create;
  GlobalSettings := TStringList.Create;
  ApplicationPath := ExtractFilePath(ParamStr(0));
  IsInitialized := True;

finalization
  if Assigned(GlobalCustomerList) then
    GlobalCustomerList.Free;
  if Assigned(GlobalSettings) then
    GlobalSettings.Free;

end.