unit main;

{$mode objfpc}{$H+}

interface

uses
  SysUtils, DateUtils, Forms, Controls, Graphics, ExtCtrls, StdCtrls;

type

  PTodoHistoryItem = ^TTodoHistoryItem;
  TTodoHistoryItem = record
    date          : TDate;
    done          : Boolean;
    doneByOthers  : Boolean;
  end;

  PTodoItem = ^TTodoItem;
  TTodoItem = record
    id            : Integer;
    name          : string;
    repeatDays    : Integer;
    daysSinceDone : Integer;
    done          : Boolean;
    doneByOthers  : Boolean;
    cancelled     : Boolean;
    planned       : Boolean;
    notPlanned    : Boolean;
    history       : array of TTodoHistoryItem;
    panel         : TPanel;
    updating      : Boolean;
  end;

  PTodoList = ^TTodoList;
  TTodoList = record
    filename      : string;
    name          : string;
    nextId        : Integer;
    date          : TDate;
    items         : array of TTodoItem;
  end;

  { TfrmMain }

  TfrmMain = class(TForm)
    bAdd: TButton;
    bNextDay: TButton;
    cbPlanned: TCheckBox;
    lDate: TLabel;
    sbTodo: TScrollBox;
    procedure bAddClick(Sender: TObject);
    procedure bNextDayClick(Sender: TObject);
    procedure cbPlannedChange(Sender: TObject);
    procedure FormActivate(Sender: TObject);
    procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
    procedure OnChangeItem(Sender: TObject);
    procedure UpdateItem(var item: TTodoItem);
    procedure ClearTodoList();
    procedure RebuildTodoList();
  private
  public
  end;
var
  frmMain: TfrmMain;
  todoList: TTodoList;

implementation

{$R *.lfm}


function BoolToInt(b: Boolean): Integer;
begin
  if b then Result := 1 else Result := 0;
end;


function DateToInt(date: TDate): Integer;
var
   y, m, d: Word;
begin
  DecodeDate(date, y, m, d);
  Result := y*10000 + m*100 + d;
end;


function IntToDate(i: Integer): TDate;
begin
  Result := EncodeDate(i div 10000, (i div 100) mod 100, i mod 100);
end;


function RoundDate(date: TDate): TDate;
begin
  Result := IntToDate( DateToInt(date) );
end;


function isPlanned(var item: TTodoItem): Boolean;
begin
  Result := item.planned or ((item.daysSinceDone >= item.repeatDays) and not item.notPlanned);
end;


function isDone(var item: TTodoItem): Boolean;
begin
  Result := item.done or item.doneByOthers;
end;


function isNeedToDo(var item: TTodoItem): Boolean;
begin
  Result := isPlanned(item) and (not item.cancelled) and not isDone(item);
end;


procedure ClearTodoList(var list: TTodoList);
begin
  list.filename := '';
  list.name := '';
  list.nextId := 0;
  setLength(list.items, 0);
end;


function SaveTodoList(var list: TTodoList; filename: string): Boolean;
var
  i: Integer;
  f: textfile;
begin
  Result := False;

  AssignFile(f, filename);
  Rewrite(f);
  Writeln(f, 2); // version
  Writeln(f, list.name);
  Writeln(f, list.nextId);
  Writeln(f, DateToInt(list.date));
  Writeln(f, Length(list.items));
  for i := 0 to Length(list.items)-1 do begin
    Writeln(f, list.items[i].id);
    Writeln(f, list.items[i].name);
    Writeln(f,
      list.items[i].repeatDays, ' ',
      list.items[i].daysSinceDone, ' ',
      BoolToInt(list.items[i].done), ' ',
      BoolToInt(list.items[i].doneByOthers), ' ',
      BoolToInt(list.items[i].cancelled), ' ',
      BoolToInt(list.items[i].planned), ' ',
      BoolToInt(list.items[i].notPlanned) );
  end;
  CloseFile(f);

  Result := True;
end;


function SaveTodoListEx(var list: TTodoList): Boolean;
var
  i: Integer;
  fo, fn: string;
begin
  Result := False;
  if FileExists(list.filename) then begin
    for i := 0 to 1000 do begin
      fo := list.filename + '.old.' + IntToStr(i);
      if FileExists(fo) then fo := '' else break;
    end;
    for i := 0 to 1000 do begin
      fn := list.filename + '.new.' + IntToStr(i);
      if FileExists(fn) then fn := '' else break;
    end;
    if (fo = '') or (fn = '') then Exit;

    if not SaveTodoList(list, fn) then begin
      DeleteFile(fn);
      Exit;
    end;

    if not RenameFile(list.filename, fo) then begin
      DeleteFile(fn);
      Exit;
    end;

    if not RenameFile(fn, list.filename) then begin
      RenameFile(fo, list.filename);
      DeleteFile(fn);
      Exit;
    end;

    DeleteFile(fn);
    DeleteFile(fo);
  end else
  if not SaveTodoList(list, list.filename) then begin
    DeleteFile(list.filename);
    Exit;
  end;
  Result := True;
end;


function LoadTodoList(var list: TTodoList; filename: string): Boolean;
var
  i, version, count: Integer;
  i0, i1, i2, i3, i4: Integer;
  f: textfile;
begin
  clearTodoList(list);
  list.filename := filename;

  Result := False;
  if not FileExists(filename) then Exit;

  AssignFile(f, filename);
  Reset(f);
  Readln(f, version);
  Readln(f, list.name);
  Readln(f, list.nextId);
  Readln(f, i0);
  list.date := IntToDate(i0);
  Readln(f, count);
  setLength(list.items, count);
  for i := 0 to count-1 do begin
    Readln(f, list.items[i].id);
    Readln(f, list.items[i].name);
    if version <= 1 then begin
      Readln(f,
        list.items[i].repeatDays,
        list.items[i].daysSinceDone,
        i0, i1, i2, i3 );
      list.items[i].done         := i0 <> 0;
      list.items[i].doneByOthers := i1 <> 0;
      list.items[i].cancelled    := i3 <> 0;
      list.items[i].planned      := i2 <> 0;
      list.items[i].notPlanned   := False;
    end else begin
      Readln(f,
        list.items[i].repeatDays,
        list.items[i].daysSinceDone,
        i0, i1, i2, i3, i4 );
      list.items[i].done         := i0 <> 0;
      list.items[i].doneByOthers := i1 <> 0;
      list.items[i].cancelled    := i2 <> 0;
      list.items[i].planned      := i3 <> 0;
      list.items[i].notPlanned   := i4 <> 0;
    end;
  end;
  CloseFile(f);
  Result := True;
end;


procedure SetTodoListDate(var list: TTodoList; date: TDate);
var
  i, d: Integer;
begin
  date := RoundDate(date);
  d := DaysBetween(date, list.date);
  if (date < list.date) and (d > 0) then d := -d;
  list.date := date;
  if d = 0 then Exit;
  for i := 0 to Length(list.items)-1 do begin
    Inc(list.items[i].daysSinceDone, d);
    if d < 0 then begin
      if list.items[i].daysSinceDone < 1 then
         list.items[i].daysSinceDone := 1;
    end else begin
      if isDone(list.items[i]) then begin
        list.items[i].daysSinceDone := d;
        list.items[i].planned := False;
      end;
      list.items[i].done := False;
      list.items[i].doneByOthers := False;
      list.items[i].cancelled := False;
      list.items[i].notPlanned := False;
    end
  end
end;


procedure AddTodoItem(var list: TTodoList);
var
  i: Integer;
begin
  i := Length(list.items);
  SetLength(list.items, i + 1);
  list.items[i].id := list.nextId;
  list.items[i].repeatDays := 1;
  list.items[i].daysSinceDone := 1;
  Inc(list.nextId);
end;


procedure RemoveTodoItem(var list: TTodoList; i: Integer);
var
  j: Integer;
begin
  if (i < 0) or (i >= Length(list.items)) then Exit;
  for j := i+1 to Length(list.items)-1 do
    list.items[j-1] := list.items[j];
  SetLength(list.items, Length(list.items) - 1);
end;


procedure InsertTodoItem(var list: TTodoList; i: Integer; item: TTodoItem);
var
  j: Integer;
begin
  if i < 0 then i := 0;
  if i > Length(list.items) then i := Length(list.items);
  SetLength(list.items, Length(list.items) + 1);
  for j := Length(list.items)-1 downto i+1 do
    list.items[j] := list.items[j-1];
  list.items[i] := item;
end;


procedure TfrmMain.bAddClick(Sender: TObject);
begin
  AddTodoItem(todoList);
  RebuildTodoList();
end;

procedure TfrmMain.bNextDayClick(Sender: TObject);
begin
  SetTodoListDate(todoList, IncDay(todoList.date));
  RebuildTodoList();
end;

procedure TfrmMain.cbPlannedChange(Sender: TObject);
begin
  RebuildTodoList();
end;

procedure TfrmMain.FormActivate(Sender: TObject);
begin
  if todoList.filename <> '' then Exit;
  LoadTodoList(todoList, 'todo.list');
  SetTodoListDate(todoList, Date);
  RebuildTodoList();
end;


procedure TfrmMain.FormClose(Sender: TObject; var CloseAction: TCloseAction);
begin
  SaveTodoListEx(todoList);
  CloseAction := caFree;
end;


procedure TfrmMain.OnChangeItem(Sender: TObject);
var
  p: TPanel;
  i: Integer;
  n: string;
  item: TTodoItem;

  function ParseInt(s: string): Integer;
  begin
    Result := StrToInt(s);
    if Result < 1 then Result := 1;
  end;

begin
  p := TPanel(TControl(Sender).Parent);
  i := p.Tag;

  n := TControl(Sender).Name;
  if n = 'delete' then begin
    RemoveTodoItem(todoList, i);
    RebuildTodoList();
  end else
  if n = 'up' then begin
    item := todoList.items[i];
    RemoveTodoItem(todoList, i);
    InsertTodoItem(todoList, i-1, item);
    RebuildTodoList();
  end else
  if n = 'down' then begin
    item := todoList.items[i];
    RemoveTodoItem(todoList, i);
    InsertTodoItem(todoList, i+1, item);
    RebuildTodoList();
  end else begin
    with todoList.items[i] do begin
      if updating then Exit;
      name          := TEdit( p.FindChildControl('name') ).Text;
      repeatDays    := ParseInt(TEdit( p.FindChildControl('repeatDays')    ).Text);
      daysSinceDone := ParseInt(TEdit( p.FindChildControl('daysSinceDone') ).Text);
      done          := TCheckBox( p.FindChildControl('done')         ).Checked;
      doneByOthers  := TCheckBox( p.FindChildControl('doneByOthers') ).Checked;
      cancelled     := TCheckBox( p.FindChildControl('cancelled')    ).Checked;
      planned       := TCheckBox( p.FindChildControl('planned')      ).Checked;
      notPlanned    := TCheckBox( p.FindChildControl('notPlanned')   ).Checked;
    end;
    UpdateItem(todoList.items[i]);
  end;

  SaveTodoListEx(todoList);
end;


procedure TfrmMain.UpdateItem(var item: TTodoItem);
begin
  item.updating := True;
  with item.panel do begin
    if item.cancelled then
      item.panel.Font.StrikeThrough := True
    else
      item.panel.Font.StrikeThrough := False;

    if isNeedToDo(item) then
      item.panel.Font.Color := clDefault
    else
      item.panel.Font.Color := clGrayText;

    TCheckBox( FindChildControl('done')         ).Checked := item.done;
    TCheckBox( FindChildControl('doneByOthers') ).Checked := item.doneByOthers;
    TCheckBox( FindChildControl('cancelled')    ).Checked := item.cancelled;
    TCheckBox( FindChildControl('planned')      ).Checked := item.planned;
    TCheckBox( FindChildControl('notPlanned')   ).Checked := item.notPlanned;
    TEdit( FindChildControl('daysSinceDone') ).Text := IntToStr(item.daysSinceDone);
    TEdit( FindChildControl('repeatDays')    ).Text := IntToStr(item.repeatDays);
    TEdit( FindChildControl('name')          ).Text := item.name;
  end;
  item.updating := False;
end;


procedure TfrmMain.ClearTodoList();
var
  i: Integer;
begin
  while sbTodo.ControlCount > 0 do
    sbTodo.Controls[0].Destroy();
  for i := 0 to Length(todoList.items)-1 do
    todoList.items[i].panel := nil;
  sbTodo.UpdateScrollbars;
end;


procedure TfrmMain.RebuildTodoList();
const
  b = 0;
  bb = 2;
  sb = 16;
var
  i, j, h, t, l, ll, r: Integer;
  scroll: Integer;
  plannedOnly: Boolean;
  p: TPanel;

  function createCheckBox(name, title: string): TCheckBox;
  begin
    Result := TCheckBox.Create(p);
    Result.Name := name;
    Result.Caption := '';
    Result.Hint := title;
    Result.ShowHint := True;
    Result.Top := bb;
    Result.Left := l;
    Result.OnChange := @OnChangeItem;
    p.InsertControl(Result);
    Inc(l, Result.Width);
  end;

  function createButton(name, title: string): TButton;
  begin
    Result := TButton.Create(p);
    Result.Name := name;
    Result.Caption := title;
    Result.ParentFont := True;
    Result.Top := bb;
    Result.Left := r - Result.Width;
    Result.Anchors := [akTop, akRight];
    Result.OnClick := @OnChangeItem;
    p.InsertControl(Result);
    r := Result.Left;
  end;

  function createSquareButton(name, title: string): TButton;
  begin
    Result := createButton(name, title);
    Result.Left := Result.Left + Result.Width - Result.Height;
    Result.Width := Result.Height;
    r := Result.Left;
  end;

  function createEdit(name, title: string): TEdit;
  begin
    Result := TEdit.Create(p);
    Result.Name := name;
    Result.Hint := Title;
    Result.ShowHint := True;
    Result.AutoSize := False;
    Result.BorderStyle := bsNone;
    Result.ParentFont := True;
    Result.ParentColor := True;
    Result.Width := Result.Height*2;
    Result.NumbersOnly := True;
    Result.Top := bb;
    Result.Left := r - Result.Width;
    Result.Anchors := [akTop, akRight];
    Result.OnEditingDone := @OnChangeItem;
    p.InsertControl(Result);
    r := Result.Left;
  end;

  function createNameEdit(name, title: string): TEdit;
  begin
    Result := createEdit(name, title);
    Result.NumbersOnly := False;
    Result.Left := l;
    Result.Width := Result.Width + r - l;
    Result.Anchors := [akLeft, akTop, akRight];
  end;

begin
  scroll := sbTodo.VertScrollBar.Position;
  plannedOnly := cbPlanned.Checked;

  ClearTodoList();

  lDate.Caption := FormatDateTime('YYYY-MM-DD', todoList.date);

  t := b;
  for i := 0 to Length(todoList.items)-1 do begin
    if plannedOnly and not isPlanned(todoList.items[i]) then
      Continue;

    p := TPanel.Create(sbTodo);
    p.Tag := i;
    p.Left := b;
    p.Width := sbTodo.Width - b*2 - sb;
    p.Top := t;
    p.Anchors := [akLeft, akTop, akRight];
    p.ParentFont := False;
    sbTodo.InsertControl(p);

    l := bb;

    createCheckBox('done', 'Done');
    createCheckBox('doneByOthers', 'Done by others');
    createCheckBox('cancelled', 'Cancelled');
    ll := l;
    Inc(l, bb);
    Inc(l, bb);
    Inc(l, bb);
    createCheckBox('planned', 'Planned manually').Visible := not plannedOnly;
    createCheckBox('notPlanned', 'Remove from plan manually').Visible := not plannedOnly;
    if plannedOnly then l := ll;
    Inc(l, bb);

    r := p.ClientWidth - bb;

    createButton('delete', 'delete');
    Dec(r, bb);
    createSquareButton('down', '+');
    createSquareButton('up', '-');
    Dec(r, bb);

    createEdit('daysSinceDone', 'Days since last done');
    Dec(r, bb);
    createEdit('repeatDays', 'Repeat every N days');
    Dec(r, bb);
    createNameEdit('name', 'Task name');

    h := 0;
    for j := 0 to p.ControlCount-1 do
      if h < p.Controls[j].Top + p.Controls[j].Height then
        h := p.Controls[j].Top + p.Controls[j].Height;
    p.Height := h + bb;
    Inc(t, p.Height + b);

    todoList.items[i].panel := p;
    UpdateItem(todoList.items[i]);
  end;
  sbTodo.UpdateScrollbars;

  sbTodo.ScrollBy(0, -scroll);
end;


end.