using System;
using System.Data;
using System.IO;
using System.Collections;
using Iva.CsNet.CSNControls;

namespace Iva.CsNet.CSNControls
{
/// <summary>
/// Summary description for FoxUtils.
/// </summary>
#region FoxTable
public sealed class FoxTable:IDisposable
{
#region Constructors
#region Private
private FoxTable(string fileName)
{
FileName=fileName;
}
#endregion

#region Use
public static FoxTable Use(string fileName)
{
return Use(fileName,false);
}

public static FoxTable Use(string fileName,bool readOnly)
{
if (StringLib.Empty(fileName))
throw new ArgumentException("Не указано ім'я файлу таблиці");
FoxTable ft=new FoxTable(fileName);
ft.readOnly=readOnly;
if (!File.Exists(fileName))
throw new FileNotFoundException("Файл не знайдено",fileName);
//ft.fs_dbf=File.Open(fileName,FileMode.Open,FileAccess.ReadWrite,FileShare.ReadWrite);
ft.fs_dbf=new BufferedStream(File.Open(fileName,FileMode.Open,FileAccess.ReadWrite,FileShare.ReadWrite));
try
{
ft.ValidateStructure();
return ft;
}
catch
{
ft.fs_dbf.Close();
if (ft.fs_fpt!=null)
ft.fs_fpt.Close();
throw;
}
}
#endregion

#region Create
public static FoxTable Create(string fileName, FoxField[] structure)
{
return Create(fileName,structure,866,true);
}

public static FoxTable Create(string fileName, FoxField[] structure,int codepage,bool overWriteIfExists)
{
FoxTable ft=new FoxTable(fileName);
if (StringLib.Empty(fileName))
throw new ArgumentNullException("Не указано ім'я файлу таблиці");
if (File.Exists(fileName) && !overWriteIfExists)
throw new ApplicationException("Файл "+fileName+" уже існує");
if (structure==null)
throw new ArgumentNullException("Не указано стуктуру таблиці");
//ft.fs_dbf=File.Create(fileName);
ft.fs_dbf=new BufferedStream(File.Create(fileName));
try
{
ft.fields=structure;
ft.cpdbf=codepage;
ft.CreateStructure();
return ft;
}
catch
{
ft.fs_dbf.Close();
if (ft.fs_fpt!=null)
ft.fs_fpt.Close();
throw;
}
}
#endregion
#endregion

#region Variables and Properties
public readonly string FileName;
System.Text.Encoding encoding;
//int LOCKDELAY=50;
//int LOCKATTEMPTS=10;
private short[] field_offsets;
int recno=0;
bool dirty_dbf=false;
bool dirty_fpt=false;
SortedList recBuffer=new SortedList();

private FoxField[] fields;
public FoxField[] Fields
{
get
{
return fields;
}
}

private int cpdbf;
public int CPDBF
{
get {return cpdbf;}
}

BufferedStream fs_dbf;
//private FileStream fs_dbf;
private bool hasMemo=false;
private FileStream fs_fpt;
private short memoBlockSize=64;

private bool readOnly;
public bool ReadOnly
{
get {return readOnly;}
}

private short headerLength,recordLength;
#endregion

#region Internal Methods
#region IDisposable Members
private bool closed=false;
public void Dispose()
{
Close();
}

public void Close()
{
Flush();
closed=true;
if (fs_dbf!=null)
{
fs_dbf.Close();
fs_dbf=null;
}
if (fs_fpt!=null)
{
fs_fpt.Close();
fs_fpt=null;
}
}
#endregion

#region ValidateStructure
void ValidateStructure()
{
byte[] buffer=new byte[32];
if (fs_dbf.Read(buffer,0,32)<32)
throw new FoxFileFormatException();
if (buffer[0]!=3 && buffer[0]!=0xF5)
throw new FoxFileFormatException();
bool hasMemo1=(buffer[0]==0xF5);
int recc=buffer[4]+buffer[5]*256+buffer[6]*256*256+buffer[7]*256*256*256;
headerLength=(short)(buffer[8]+buffer[9]*256);
recordLength=(short)(buffer[10]+buffer[11]*256);
if (buffer[29]==0)
cpdbf=0;
else if (buffer[29]==0x65)
cpdbf=866;
else if (buffer[29]==0xC9)
cpdbf=1251;
else
throw new ApplicationException("Помилка кодової таблиці файлу");
encoding=System.Text.Encoding.GetEncoding(cpdbf);
if (fs_dbf.Length!=headerLength+recc*recordLength+(recc>0?1:0))
throw new FoxFileFormatException();
if ((headerLength-1)%32!=0)
throw new FoxFileFormatException();
short fcount=(short)((headerLength-1)/32-1);
fields=new FoxField[fcount];
field_offsets=new short[fcount];
string f_name;
char f_type;
byte f_len,f_dec;
for (short i=0;i<fcount;i++)
{
if (fs_dbf.Read(buffer,0,32)<32)
throw new FoxFileFormatException();
f_name=(new string(encoding.GetChars(buffer,0,10))).Replace(new string((char)0,1),"").ToUpper();
if (buffer[10]!=0)
throw new FoxFileFormatException();
f_type=encoding.GetChars(buffer,11,1)[0];
f_len=buffer[16];
f_dec=buffer[17];
fields =new FoxField(f_name,f_type,f_len,f_dec);
field_offsets=(short)(buffer[12]+buffer[13]*256+buffer[14]*256*256+buffer[15]*256*256*256);
if (f_type=='M')
hasMemo=true;
}
if (hasMemo!=hasMemo1)
throw new FoxFileFormatException();
if (hasMemo)
{
string fptName=StringLib.AddExt(FileName,"fpt");
if (!File.Exists(fptName))
throw new FileNotFoundException("Файл не знайдено",fptName);
fs_fpt=File.Open(fptName,FileMode.Open,FileAccess.ReadWrite,FileShare.ReadWrite);
buffer=new byte[512];
if (fs_fpt.Read(buffer,0,512)<512)
throw new FoxFileFormatException();
memoBlockSize=(short)(buffer[6]*256+buffer[7]);
if (memoBlockSize==0)
throw new FoxFileFormatException();
}
}
#endregion

#region CreateStructure
void CreateStructure()
{
hasMemo=false;
recordLength=1;
field_offsets=new short[Fields.Length];
for (short i=0;i<Fields.Length;i++)
{
field_offsets=recordLength;
recordLength+=Fields.FieldLen;
if (Fields.FieldType==FoxTypes.Memo)
hasMemo=true;
}
byte[] buffer=new byte[32];
if (hasMemo)
buffer[0]=0xF5;
else
buffer[0]=3;
headerLength=(short)(32*(Fields.Length+1)+1);
buffer[8]=(byte)(headerLength%256);
buffer[9]=(byte)(headerLength/256);
buffer[10]=(byte)(recordLength%256);
buffer[11]=(byte)(recordLength/256);
if (cpdbf==866 || cpdbf==0)
buffer[29]=0x65;
else if (cpdbf==1251)
buffer[29]=0xC9;
else
throw new ArgumentException("Кодова сторінка "+cpdbf.ToString()+" не підтримується");
fs_dbf.Write(buffer,0,32);
encoding=System.Text.Encoding.GetEncoding(cpdbf);
for (short i=0;i<Fields.Length;i++)
{
FoxField fld=Fields;
buffer=new byte[32];
if (StringLib.Empty(fld.FieldName))
throw new ArgumentNullException("Відсутня назва поля");
else if (fld.FieldName.Length>10)
throw new ArgumentException("Недопустима довжина назви поля "+fld.FieldName+".");
else if (!Char.IsLetter(fld.FieldName[0]) && fld.FieldName[0]!='_')
throw new ArgumentException("Недопустима назва поля "+fld.FieldName+".");
if (encoding.GetBytes(fld.FieldName,0,fld.FieldName.Length,buffer,0)>10)
throw new ArgumentException("Недопустима назва поля "+fld.FieldName+".");
buffer[11]=(byte)FoxField.e2c(fld.FieldType);
buffer[16]=fld.FieldLen;
buffer[17]=fld.FieldDec;
buffer[12]=(byte)(field_offsets%256);
buffer[13]=(byte)(field_offsets/256);
fs_dbf.Write(buffer,0,32);
}
fs_dbf.WriteByte(13);
string fptName=StringLib.AddExt(FileName,"fpt");
if (hasMemo)
{
fs_fpt=File.Create(fptName);
buffer=new byte[512];
memoBlockSize=64;
buffer[3]=9;
buffer[7]=(byte)(memoBlockSize%256);
buffer[6]=(byte)(memoBlockSize/256);
fs_fpt.Write(buffer,0,512);
}
else
{
if (File.Exists(fptName))
File.Delete(fptName);
}
string cdxName=StringLib.AddExt(FileName,"cdx");
if (File.Exists(cdxName))
File.Delete(cdxName);
}
#endregion

#region TestForClosed
void TestForClosed()
{
if (closed)
throw new FoxClosedException();
}
#endregion

#region HeadRecc
int GetHeadRecc()
{
TestForClosed();
byte[] buffer=new byte[4];
fs_dbf.Position=4;
fs_dbf.Read(buffer,0,4);
return buffer[0]+buffer[1]*256+buffer[2]*256*256+buffer[3]*256*256*256;
}

void SetHeadRecc(int recc)
{
TestForClosed();
int r;
byte[] buffer=new byte[4];
r=recc;
for (int i=0;i<4;i++)
{
buffer=(byte)(r%256);
r=r/256;
}
fs_dbf.Position=4;
fs_dbf.Write(buffer,0,4);
}
#endregion

#region Flush & Buffer
void Flush()
{
if (readOnly || !dirty_dbf && !dirty_fpt)
return;
TestForClosed();
if (Recno<1)
return;
SetDeleted(deleted);
for (int i=0;i<Fields.Length;i++)
{
if (Fields.FieldType==FoxTypes.Memo && dirty_fpt ||
Fields.FieldType!=FoxTypes.Memo && dirty_dbf)
FlushField(i,recBuffer[Fields.FieldName]);
}
dirty_dbf=false;
dirty_fpt=false;
}

void Buffer()
{
TestForClosed();
if (Recno<1)
return;
recBuffer.Clear();
deleted=GetDeleted();
for (int i=0;i<Fields.Length;i++)
recBuffer.Add(Fields.FieldName,BufferField(i));
}

public bool GetDeleted()
{
fs_dbf.Position=GetFieldStartPos(-1);
return (fs_dbf.ReadByte()!=32);
}

public void SetDeleted(bool _value)
{
fs_dbf.Position=GetFieldStartPos(-1);
if (_value)
fs_dbf.WriteByte(42);
else
fs_dbf.WriteByte(32);
}

public object BufferField(int fieldIndex)
{
fs_dbf.Position=GetFieldStartPos(fieldIndex);
byte[] buffer=new byte[Fields[fieldIndex].FieldLen];
fs_dbf.Read(buffer,0,buffer.Length);
bool isNull=true;
for (int i=0;i<buffer.Length;i++)
{
if(buffer!=32)
{
isNull=false;
break;
}
}
if (isNull)
return DBNull.Value;
switch (Fields[fieldIndex].FieldType)
{
case (FoxTypes.Character):
return encoding.GetString(buffer);
case (FoxTypes.Date):
string s=encoding.GetString(buffer);
try
{
return new DateTime(Int32.Parse(s.Substring(0,4)),
Int32.Parse(s.Substring(4,2)),Int32.Parse(s.Substring(6,2)));
}
catch
{
return DBNull.Value;
}
case (FoxTypes.Logical):
if (buffer[0]=='1' || buffer[0]=='Y' || buffer[0]=='y' || buffer[0]=='T' || buffer[0]=='t')
return true;
else
return false;
case (FoxTypes.Memo):
try
{
s=encoding.GetString(buffer).Trim();
if (StringLib.Empty(s))
return DBNull.Value;
int bn=Int32.Parse(s);
if (bn<=0)
return DBNull.Value;
fs_fpt.Position=memoBlockSize*bn;
byte[] buffer1=new byte[8];
fs_fpt.Read(buffer1,0,8);
int len=buffer1[4]*256*256*256+buffer1[5]*256*256+buffer1[6]*256+buffer1[7];
if (len==0)
return DBNull.Value;
buffer1=new byte[len];
fs_fpt.Read(buffer1,0,len);
return encoding.GetString(buffer1);
}
catch
{
return DBNull.Value;
}
case (FoxTypes.Number):
try
{
return Decimal.Parse(encoding.GetString(buffer).Trim());
}
catch
{
return DBNull.Value;
}
default:
throw new NotImplementedException();
}
}

public void FlushField(int fieldIndex, object _value)
{
byte[] buffer=new byte[Fields[fieldIndex].FieldLen];
for (int i=0;i<buffer.Length;i++)
buffer=32;
string es="Невірний тип змінної для внесення в поле "+Fields[fieldIndex].FieldName+".";
string s=null;
if (_value!=null && _value!=DBNull.Value)
{
switch (Fields[fieldIndex].FieldType)
{
case (FoxTypes.Character):
if (_value.GetType()!=typeof(string))
throw new ArgumentException(es);
s=(string)_value;
break;
case (FoxTypes.Date):
if (_value.GetType()!=typeof(DateTime))
throw new ArgumentException(es);
else
{
DateTime dt=(DateTime)_value;
s=dt.Year.ToString().PadLeft(4,'0')+
dt.Month.ToString().PadLeft(2,'0')+
dt.Day.ToString().PadLeft(2,'0');
break;
}
case (FoxTypes.Logical):
if (_value.GetType()!=typeof(bool))
throw new ArgumentException(es);
if ((bool)_value)
s="T";
else
s="F";
break;
case (FoxTypes.Number):
decimal dm;
if (_value.GetType()==typeof(Int32))
dm=new Decimal((int)_value);
else if (_value.GetType()==typeof(Int16))
dm=new Decimal((short)_value);
else if (_value.GetType()==typeof(Int64))
dm=new Decimal((long)_value);
else if (_value.GetType()==typeof(Decimal))
dm=(Decimal)_value;
else if (_value.GetType()==typeof(Double))
dm=new Decimal((Double)_value);
else
throw new ArgumentException(es);
try
{
s=StringLib.IStr(dm,Fields[fieldIndex].FieldLen,Fields[fieldIndex].FieldDec,Fields[fieldIndex].FieldDec);
}
catch (OverflowException err)
{
throw new OverflowException(err.Message+" Поле "+Fields[fieldIndex].FieldName+".");
}
break;
case (FoxTypes.Memo):
if (_value.GetType()!=typeof(string))
throw new ArgumentException(es);
string memoValue=(string)_value;
fs_dbf.Position=GetFieldStartPos(fieldIndex);
fs_dbf.Read(buffer,0,buffer.Length);
s=encoding.GetString(buffer);
int bn=0;
if (!StringLib.Empty(s))
{
try
{
bn=Int32.Parse(s);
}
catch
{
bn=0;
}
}
bool newpos=false;
byte[] buffer1;
buffer1=new byte[8];
if (bn>0)
{
fs_fpt.Position=memoBlockSize*bn;
fs_fpt.Read(buffer1,0,8);
int len=buffer1[4]*256*256*256+buffer1[5]*256*256+buffer1[6]*256+buffer1[7];
if (GetBlockCount(memoValue.Length)>GetBlockCount(len))
newpos=true;
}
else
newpos=true;
if (newpos)
{
//New Position in FPT
bn+=GetBlockCount(memoValue.Length);
s=bn.ToString().PadLeft(10);
buffer1[3]=1;
}
fs_fpt.Position=memoBlockSize*bn;
byte[] rv=ByteLib.IntTo4Bytes(memoValue.Length);
buffer1[4]=rv[0];
buffer1[5]=rv[1];
buffer1[6]=rv[2];
buffer1[7]=rv[3];
fs_fpt.Write(buffer1,0,buffer1.Length);
buffer1=new byte[memoValue.Length];
encoding.GetBytes(memoValue,0,memoValue.Length,buffer1,0);
fs_fpt.Write(buffer1,0,buffer1.Length);
break;
default:
throw new NotImplementedException();
}
if (!StringLib.Empty(s))
encoding.GetBytes(s,0,Math.Min(s.Length,buffer.Length),buffer,0);
}
fs_dbf.Position=GetFieldStartPos(fieldIndex);
fs_dbf.Write(buffer,0,buffer.Length);
}

int GetBlockCount(int len)
{
if ((len+8)%memoBlockSize==0)
return (len+8)/memoBlockSize;
else
return (len+8)/memoBlockSize+1;
}

int GetFieldStartPos(int fieldIndex)
{
if (fieldIndex>=0)
return headerLength+(recno-1)*recordLength+field_offsets[fieldIndex];
else
return headerLength+(recno-1)*recordLength;
}
#endregion

#region GetFieldIndex
int GetFieldIndex(string fieldName)
{
for (int i=0;i<Fields.Length;i++)
{
if (Fields.FieldName==fieldName)
return i;
}
return -1;
}
#endregion

#region CreateDataTableFields
private void CreateDataTableFields(DataTable table)
{
for (int i=0;i<Fields.Length;i++)
{
DataColumn col=new DataColumn(Fields.FieldName);
switch (Fields.FieldType)
{
case FoxTypes.Character:
col.DataType=typeof(string);
break;
case FoxTypes.Date:
col.DataType=typeof(DateTime);
break;
case FoxTypes.Logical:
col.DataType=typeof(bool);
break;
case FoxTypes.Memo:
col.DataType=typeof(string);
break;
case FoxTypes.Number:
if (Fields.FieldDec==0 && Fields.FieldLen<10)
col.DataType=typeof(int);
else
col.DataType=typeof(decimal);
break;
default:
throw new NotImplementedException();
}
table.Columns.Add(col);
}
}
#endregion
#endregion

#region Static Exchange Methods

#endregion

#region Fox Methods
public void Gather(DataRow row)
{
TestForClosed();
if (Recno<1 || Recno>Reccount)
throw new ApplicationException("Не вибрано запису");
for (short i=0;i<Fields.Length;i++)
{
if (row.Table.Columns.Contains(Fields.FieldName))
SetFieldValue(i,row[Fields.FieldName]);
}
}

public void GatherAll(DataTable table)
{
GatherAll(table.DefaultView);
}

public void GatherAll(DataView view)
{
for (int i=0;i<view.Count;i++)
Append(view.Row);
}

public void Scatter(DataRow row)
{
TestForClosed();
if (Recno<1 || Recno>Reccount)
throw new ApplicationException("Не вибрано запису");
for (short i=0;i<Fields.Length;i++)
{
if (row.Table.Columns.Contains(Fields.FieldName))
row[Fields.FieldName]=GetFieldValue(i);
}
}

public void ScatterAll(DataTable table)
{
if (table.Columns.Count==0)
CreateDataTableFields(table);
table.BeginLoadData();
try
{
int rc=Reccount;
for (int i=1;i<=rc;i++)
{
Go(i);
if (Deleted)
continue;
DataRow row=table.NewRow();
Scatter(row);
table.Rows.Add(row);
}
}
finally
{
table.EndLoadData();
}
}

public object GetFieldValue(string fieldName)
{
TestForClosed();
fieldName=fieldName.ToUpper();
if(GetFieldIndex(fieldName)<0)
throw new ArgumentException("Поле "+fieldName+" відсутнє в таблиці");
return recBuffer[fieldName];
}

public object GetFieldValue(int fieldIndex)
{
TestForClosed();
if (fieldIndex<0 || fieldIndex>=Fields.Length)
throw new IndexOutOfRangeException();
return recBuffer[Fields[fieldIndex].FieldName];
}

public void SetFieldValue(string fieldName, object _value)
{
TestForClosed();
fieldName=fieldName.ToUpper();
int fi=GetFieldIndex(fieldName);
if(fi<0)
throw new ArgumentException("Поле "+fieldName+" відсутнє в таблиці");
recBuffer[fieldName]=_value;
if (Fields[fi].FieldType==FoxTypes.Memo)
dirty_fpt=true;
else
dirty_dbf=true;
}

public void SetFieldValue(int fieldIndex, object _value)
{
TestForClosed();
if (fieldIndex<0 || fieldIndex>=Fields.Length)
throw new IndexOutOfRangeException();
recBuffer[Fields[fieldIndex].FieldName]=_value;
if (Fields[fieldIndex].FieldType==FoxTypes.Memo)
dirty_fpt=true;
else
dirty_dbf=true;
}

public void Append(DataRow row)
{
TestForClosed();
AppendBlank();
Gather(row);
}

public void AppendBlank()
{
TestForClosed();
Flush();
if (!LockHeader())
throw new ApplicationException("Помилка блокування заголовку таблиці");
byte[] buffer=new byte[recordLength+1];
for (int i=0;i<recordLength;i++)
buffer=0x20;
buffer[recordLength]=0x1a;

if (Reccount==0)
fs_dbf.Position=fs_dbf.Length;
else
fs_dbf.Position=fs_dbf.Length-1;
fs_dbf.Write(buffer,0,recordLength+1);
recno=GetHeadRecc()+1;
SetHeadRecc(recno);
Unlock();
}

public void Go(int recno)
{
if (recno>Reccount)
throw new IndexOutOfRangeException();
Flush();
this.recno=recno;
Buffer();
}

public void Delete()
{
TestForClosed();
if (Recno==0)
return;
deleted=true;
dirty_dbf=true;
}

public void Recall()
{
TestForClosed();
if (Recno==0)
return;
deleted=false;
dirty_dbf=true;
}

bool Lock()
{
return true;
}

bool LockTable()
{
return true;
}

bool LockHeader()
{
return true;
}

public void Unlock()
{}

private bool deleted=false;
public bool Deleted
{
get
{
TestForClosed();
return deleted;
}
}

public int Reccount
{
get
{
TestForClosed();
return GetHeadRecc();
}
}

public int Recno
{
get
{
TestForClosed();
return recno;
}
}
#endregion

#region Exceptions
public sealed class FoxFileFormatException:ApplicationException
{
public FoxFileFormatException():base("Помилка формату файлу")
{}
}

public sealed class FoxClosedException:ApplicationException
{
public FoxClosedException():base("Недопустима операція для закритої таблиці")
{}
}
#endregion
}
#endregion

#region FoxField
public struct FoxField
{
public readonly string FieldName;
public readonly FoxTypes FieldType;
public readonly byte FieldLen;
public readonly byte FieldDec;

public FoxField(string fieldName,FoxTypes fieldType, byte fieldLen, byte fieldDec)
{
if (fieldName==null || fieldName.Length<1 || fieldName.Length>10)
throw new ArgumentException("Недопустима назва поля "+fieldName+".");
FieldName=fieldName.ToUpper();
FieldType=fieldType;
FieldLen=0;
FieldDec=0;
switch (fieldType)
{
case FoxTypes.Character:
if (fieldLen<1)
throw new ArgumentException("Недопустима довжина поля "+fieldName+".");
if (fieldLen>254)
throw new ArgumentException("Недопустима довжина поля "+fieldName+".");
FieldLen=fieldLen;
FieldDec=0;
break;
case FoxTypes.Number:
if (fieldLen<1)
throw new ArgumentException("Недопустима довжина поля "+fieldName+".");
if (fieldLen>18)
throw new ArgumentException("Недопустима довжина поля "+fieldName+".");
FieldLen=fieldLen;
if (fieldDec>fieldLen-2)
throw new ArgumentException("Недопустима точність поля "+fieldName+".");
FieldDec=fieldDec;
break;
case FoxTypes.Logical:
FieldLen=1;
FieldDec=0;
break;
case FoxTypes.Date:
FieldLen=8;
FieldDec=0;
break;
case FoxTypes.Memo:
FieldLen=10;
FieldDec=0;
break;
}
}

public FoxField(string fieldName,char fieldType, byte fieldLen, byte fieldDec):this(fieldName,c2e(fieldType),fieldLen,fieldDec)
{}

public FoxField(string fieldName,char fieldType, byte fieldLen):this(fieldName,fieldType,fieldLen,0)
{}

public FoxField(string fieldName,char fieldType):this(fieldName,fieldType,0,0)
{}

static FoxTypes c2e(char fieldType)
{
switch (fieldType)
{
case 'C':
return FoxTypes.Character;
case 'N':
return FoxTypes.Number;
case 'L':
return FoxTypes.Logical;
case 'D':
return FoxTypes.Date;
case 'M':
return FoxTypes.Memo;
default:
throw new ArgumentException("Недопустимий тип поля");
}
}

internal static char e2c(FoxTypes foxType)
{
switch (foxType)
{
case FoxTypes.Character:
return 'C';
case FoxTypes.Number:
return 'N';
case FoxTypes.Date:
return 'D';
case FoxTypes.Logical:
return 'L';
case FoxTypes.Memo:
return 'M';
default:
throw new ArgumentException("Недопустимий тип поля");
}
}
}
#endregion

#region FoxTypes
public enum FoxTypes
{
Character,Number,Logical,Date,Memo
}
#endregion
}