cubix

unit db;

{$I cubix.inc}

interface

uses
  SysUtils;

const
  AllowedFlags = ['a'..'z', 'A'..'Z'];

type
  TFlagSet = set of Char;

  PUser = ^TUser;
  PChannel = ^TChannel;
  PBan = ^TBan;
  PChanAcc = ^TChanAcc;

  TUser = record
    NickName: string;
    UserName: string;
    HostName: string;
    RealName: string;
    Hand: string;
    CommandFlood: Integer;
    IsWellKnown: Boolean;
    Next: PUser;
    Prev: PUser;
    Acc: PChanAcc;
  end;

  TChannel = record
    Name: string;
    Topic: string;
    Key: string;
    Mode: TFlagSet;
    Limit: Integer;
    Prev: PChannel;
    Next: PChannel;
    Acc: PChanAcc;
    Ban: PBan;
    GotNickList: Boolean;
    GotBanList: Boolean;
    GotMode: Boolean;
  end;

  TBan = record
    Mask: string;
    Maker: string;
    Date: Cardinal;
    Prev: PBan;
    Next: PBan;
    Channel: PChannel;
  end;

  TChanAcc = record
    Flags: TFlagSet;
    LineFlood: Integer;
    CharFlood: Integer;
    CtcpFlood: Integer;
    User: PUser;
    Channel: PChannel;
    PrevChan: PChanAcc;
    NextChan: PChanAcc;
    PrevUser: PChanAcc;
    NextUser: PChanAcc;
  end;

function NewUser: PUser;
function NewChannel: PChannel;
function NewBan(AChannel: PChannel): PBan;
function NewAcc(AUser: PUser; AChannel: PChannel): PChanAcc;


function GetUser(NickName: string): PUser;
function GetChannel(Name: string): PChannel;
function GetBan(Channel: PChannel; Mask: string): PBan;
function GetAcc(User: PUser; Channel: PChannel): PChanAcc;

function GetChanCount(User: PUser): Integer;
function GetUserCount(Channel: PChannel): Integer;
function GetBanCount(Channel: PChannel): Integer;
function GetUserFromIndex(Channel: PChannel; Index: Integer): PUser;
function GetChannelFromIndex(User: PUser; Index: Integer): PChannel;
function GetBanFromIndex(Channel: PChannel; Index: Integer): PBan;

procedure FreeUser(User: PUser);
procedure FreeChannel(Channel: PChannel);
procedure FreeBan(Ban: PBan);
procedure FreeAcc(Acc: PChanAcc; Recursive: Boolean = True);

procedure ClearAll;
procedure CheckHands;

function FlagToStr(Flag: TFlagSet): string;
function StrToFlag(FlagStr: string): TFlagSet;
procedure AddFlags(var Flags: TFlagSet; AFlags: TFlagSet); overload;
procedure DelFlags(var Flags: TFlagSet; AFlags: TFlagSet); overload;
procedure AddFlags(var Flags: TFlagSet; FlagStr: string); overload;
procedure DelFlags(var Flags: TFlagSet; FlagStr: string); overload;

var
  UserRoot: PUser = nil;
  ChanRoot: PChannel = nil;

implementation

function FlagToStr(Flag: TFlagSet): string;
var
  C: Char;
begin
  Result := '+';
  for C := 'a' to 'z' do
    if C in Flag then
      Result := Result + C;
  for C := 'A' to 'Z' do
    if C in Flag then
      Result := Result + C;
end;

function StrToFlag(FlagStr: string): TFlagSet;
var
  i: Integer;
begin
  Result := [];
  for i := 1 to Length(FlagStr) do
    if FlagStr[i] in AllowedFlags then
      Include(Result, FlagStr[i]);
end;

procedure AddFlags(var Flags: TFlagSet; AFlags: TFlagSet);
begin
  Flags := Flags + AFlags;
end;

procedure DelFlags(var Flags: TFlagSet; AFlags: TFlagSet);
begin
  Flags := Flags - AFlags;
end;

procedure AddFlags(var Flags: TFlagSet; FlagStr: string);
begin
  AddFlags(Flags, FlagStr);
end;

procedure DelFlags(var Flags: TFlagSet; FlagStr: string);
begin
  DelFlags(Flags, FlagStr);
end;

function UpperCase(S: string): string;
var
  i: Integer;
begin
  Result := S;
  for i := 1 to Length(S) do
    Result[i] := UpCase(Result[i]);
end;

function GetChannel(Name: string): PChannel;
begin
  Name := UpperCase(Name);
  Result := ChanRoot;
  while Result <> nil do
  begin
    if UpperCase(Result^.Name) = Name then
      Exit;
    Result := Result^.Next;
  end;
end;

function GetBan(Channel: PChannel; Mask: string): PBan;
begin
  Mask := UpperCase(Mask);
  Result := Channel^.Ban;
  while Result <> nil do
  begin
    if UpperCase(Result^.Mask) = Mask then
      Exit;
    Result := Result^.Next;
  end;
end;

function GetUser(NickName: string): PUser;
begin
  NickName := UpperCase(NickName);
  Result := UserRoot;
  while Result <> nil do
  begin
    if UpperCase(Result^.NickName) = NickName then
      Exit;
    Result := Result^.Next;
  end;
end;

function GetAcc(User: PUser; Channel: PChannel): PChanAcc;
begin
  if (User = nil) or (Channel = nil) then
  begin
    Result := nil;
    Exit;
  end;
  Result := User^.Acc;
  while Result <> nil do
  begin
    if Result^.Channel = Channel then
      Exit;
    Result := Result^.NextChan;
  end;
end;

function GetChanCount(User: PUser): Integer;
var
  Ac: PChanAcc;
begin
  Result := 0;
  if User = nil then
    Exit;
  Ac := User^.Acc;
  while Ac <> nil do
  begin
    Inc(Result);
    Ac := Ac^.NextChan;
  end;
end;

function GetUserCount(Channel: PChannel): Integer;
var
  Ac: PChanAcc;
begin
  Result := 0;
  if Channel = nil then
    Exit;
  Ac := Channel^.Acc;
  while Ac <> nil do
  begin
    Inc(Result);
    Ac := Ac^.NextUser;
  end;
end;

function GetBanCount(Channel: PChannel): Integer;
var
  Bn: PBan;
begin
  Result := 0;
  if Channel = nil then
    Exit;
  Bn := Channel^.Ban;
  while Bn <> nil do
  begin
    Inc(Result);
    Bn := Bn^.Next;
  end;
end;

function GetUserFromIndex(Channel: PChannel; Index: Integer): PUser;
var
  i: Integer;
  Ac: PChanAcc;
begin
  if Channel = nil then
  begin
    Result := nil;
    Exit;
  end;
  Ac := Channel^.Acc;
  for i := 0 to Index - 1 do
  begin
    if Ac = nil then
    begin
      Result := nil;
      Exit;
    end;
    Ac := Ac^.NextUser;
  end;
  if Ac <> nil then
  begin
    Result := Ac^.User;
  end
  else
  begin
    Result := nil;
  end;
end;

function GetBanFromIndex(Channel: PChannel; Index: Integer): PBan;
var
  i: Integer;
  Bn: PBan;
begin
  if Channel = nil then
  begin
    Result := nil;
    Exit;
  end;
  Bn := Channel^.Ban;
  for i := 0 to Index - 1 do
  begin
    if Bn = nil then
    begin
      Result := nil;
      Exit;
    end;
    Bn := Bn^.Next;
  end;
  if Bn <> nil then
  begin
    Result := Bn;
  end
  else
  begin
    Result := nil;
  end;
end;


function GetChannelFromIndex(User: PUser; Index: Integer): PChannel;
var
  i: Integer;
  Ac: PChanAcc;
begin
  if User = nil then
  begin
    Result := nil;
    Exit;
  end;
  Ac := User^.Acc;
  for i := 0 to Index - 1 do
  begin
    if Ac = nil then
    begin
      Result := nil;
      Exit;
    end;
    Ac := Ac^.NextChan;
  end;
  if Ac <> nil then
  begin
    Result := Ac^.Channel;
  end
  else
  begin
    Result := nil;
  end;
end;

procedure ClearAll;
begin
  while UserRoot <> nil do
  begin
    FreeUser(UserRoot);
  end;
  while ChanRoot <> nil do
  begin
    FreeChannel(ChanRoot);
  end;
end;

procedure CheckHands;
var
  Us: PUser;
begin
  Us := UserRoot;
  while Us <> nil do
  begin
    if Us^.Acc = nil then
      Us^.Hand := '';
    Us := Us^.Next;
  end;
end;

function NewUser: PUser;
begin
  New(Result);
  with Result^ do
  begin
    IsWellKnown := False;
    NickName := '';
    UserName := '';
    HostName := '';
    Hand := '';
    CommandFlood := 0;
    Acc := nil;
    Prev := nil;
    Next := UserRoot;
  end;
  if UserRoot <> nil then
    UserRoot^.Prev := Result;
  UserRoot := Result;
end;

procedure FreeUser(User: PUser);
begin
  with User^ do
  begin
    if Next <> nil then
      Next^.Prev := Prev;
    if Prev <> nil then
      Prev^.Next := Next
    else
      UserRoot := Next;
    while Acc <> nil do
      FreeAcc(Acc, False);
    NickName := '';
    UserName := '';
    HostName := '';
    Hand := '';
  end;
  Dispose(User);
end;

function NewChannel: PChannel;
begin
  New(Result);
  with Result^ do
  begin
    Mode := [];
    Name := '';
    Topic := '';
    Key := '';
    Limit := 0;
    Acc := nil;
    Ban := nil;
    Prev := nil;
    GotNickList := False;
    GotBanList := False;
    GotMode := False;
    Next := ChanRoot;
  end;
  if ChanRoot <> nil then
    ChanRoot^.Prev := Result;
  ChanRoot := Result;
end;

procedure FreeChannel(Channel: PChannel);
begin
  with Channel^ do
  begin
    if Next <> nil then
      Next^.Prev := Prev;
    if Prev <> nil then
      Prev^.Next := Next
    else
      ChanRoot := Next;
    while Ban <> nil do
      FreeBan(Ban);
    while Acc <> nil do
      FreeAcc(Acc);
    Name := '';
    Topic := '';
    Key := '';
  end;
  Dispose(Channel);
end;

function NewBan(AChannel: PChannel): PBan;
begin
  New(Result);
  with Result^ do
  begin
    Mask := '';
    Maker := '';
    Date := 0;
    Channel := AChannel;
    Prev := nil;
    Next := Channel.Ban;
    if Channel^.Ban <> nil then
      Channel^.Ban^.Prev := Result;
    Channel^.Ban := Result;
  end;
end;

procedure FreeBan(Ban: PBan);
begin
  with Ban^ do
  begin
    if Next <> nil then
      Next^.Prev := Prev;
    if Prev <> nil then
      Prev^.Next := Next
    else
      Channel^.Ban := Next;
    Mask := '';
    Maker := '';
  end;
  Dispose(Ban);
end;

function NewAcc(AUser: PUser; AChannel: PChannel): PChanAcc;
begin
  New(Result);

  Result^.Flags := [];
  Result^.LineFlood := 0;
  Result^.CharFlood := 0;
  Result^.CtcpFlood := 0;

  Result^.Channel := AChannel;
  Result^.User := AUser;

  Result^.PrevChan := nil;
  Result^.NextChan := Result^.User^.Acc;
  if Result^.NextChan <> nil then
    Result^.NextChan^.PrevChan := Result;
  Result^.User^.Acc := Result;

  Result^.PrevUser := nil;
  Result^.NextUser := AChannel^.Acc;
  while (Result^.NextUser <> nil) and (UpperCase(Result^.NextUser^.User^.NickName) < UpperCase(AUser^.NickName)) do
  begin
    Result^.PrevUser := Result^.NextUser;
    Result^.NextUser := Result^.NextUser^.NextUser;
  end;

  if Result^.PrevUser = nil then
  begin
    AChannel^.Acc := Result;
  end
  else
  begin
    Result^.PrevUser^.NextUser := Result;
    if Result^.NextUser <> nil then
    begin
      Result^.NextUser^.PrevUser := Result;
    end;
  end;
end;

procedure FreeAcc(Acc: PChanAcc; Recursive: Boolean);
begin
  with Acc^ do
  begin
    if NextChan <> nil then
      NextChan^.PrevChan := PrevChan;
    if PrevChan <> nil then
      PrevChan^.NextChan := NextChan
    else
      User^.Acc := NextChan;

    if NextUser <> nil then
      NextUser^.PrevUser := PrevUser;
    if PrevUSer <> nil then
      PrevUser^.NextUser := NextUser
    else
      Channel^.Acc := NextUser;

    if Recursive then
    begin
      if (User^.Acc = nil) then
        FreeUser(User);
    end;
  end;
  Dispose(Acc);
end;

end.