int Insert(Tuple &tuple)
{
    int i,j;
    int offtest;
    char *values;
    int dp;
    int ip;
    char *t;
    int compi;
    float compf;
    bool flag;
    string comps;
    char *target = new char[1];
    int comi;
    float comf;
    values = Convertvalue(tuple);
    
    values[tuple.length()]='1';
    values[tuple.length()+1]=0;
    string file_name = tuple.table_name + "_table.rec";
    int offset = Block_num(file_name)-1;
    if(offset<0)
    {
        Block* newblock = mybuffer.GetBlock(file_name,0,1);
        memcpy(newblock->record,values,(tuple.length()+1));

        delete[] values;
        delete target;
        return 0;
    }
    else
    {
        Block* Target;
        for(i=0;i<tuple.attr_count;i++)
        {
            if(tuple.attrs[i].attr_key_type==UNIQUE)
            {
                ip=0;
                for(j=0;j<i;j++)
                {
                    ip+=tuple.attrs[j].attr_len;
                }
                for(offtest = 0;offtest<=offset;offtest++)
                {
                    Target = mybuffer.GetBlock(file_name,offtest,0);
                    for(dp=0;dp<BlockSize-tuple.length()-1;dp+=tuple.length()+1)
                    {
                        memcpy(target,Target->record+dp+tuple.length(),1);
                        if(*target=='1')
                        {
                            if(tuple.attrs[i].attr_type==CHAR)
                            {
                                t = new char[tuple.attrs[i].attr_len+1];
                                memcpy(t,Target->record+dp+ip,tuple.attrs[i].attr_len);
                                t[tuple.attrs[i].attr_len]='\0';
                                comps=t;
                                if(comps==tuple.attr_values[i])
                                {
                                    flag = true;
                                    break;
                                }
                                delete t;
                            }
                            if(tuple.attrs[i].attr_type==INT)
                            {
                                memcpy(&compi,Target->record+dp+ip,4);
                                comi=atoi(tuple.attr_values[i].c_str());
                                if(compi==comi)
                                {
                                    flag = true;
                                    break;
                                }
                            }
                            if(tuple.attrs[i].attr_type==FLOAT)
                            {
                                memcpy(&compf,Target->record+dp+ip,4);
                                comf=atof(tuple.attr_values[i].c_str());
                                if(compf==comf)
                                {
                                    flag = true;
                                    break;
                                }
                            }
                        }
                    }
                    if(flag == true)
                        break;
                }
                if(flag == true)
                    break;
            }
        }
        if(flag != true)
        {
            Target = mybuffer.GetBlock(file_name,offset,0);
            for(i=tuple.length();i<BlockSize;i+=tuple.length()+1)
            {
                if(Target->record[i] == 0)
                    break;
            }
            if(i<BlockSize)
            {
                memcpy(Target->record+i-tuple.length(),values,tuple.length()+1);
                Target->accessed = true;
                Target->written = true;
                delete[] values;
                delete target;
                return offset;
            }
            else
            {
                Block* newblock = mybuffer.GetBlock(file_name,offset+1,1);
                memcpy(newblock->record,values,tuple.length()+1);
                delete[] values;
                delete target;
                return offset+1;
            }
        }
    }

    delete[] values;
    delete target;
    return -1;
}