public void Write(Headers headers, Version version)
        {
            if (headers == null)
                throw new ArgumentNullException("headers");

            // Signature
            _writer.Write(FileFormat.SIGNATURE);

            // Database version
            _writer.Write((short)version.Minor);
            _writer.Write((short)version.Major);

            // Headers
            Write(headers, HeaderFields.CipherID);
            Write(headers, HeaderFields.CompressionFlags);
            Write(headers, HeaderFields.MasterSeed);
            Write(headers, HeaderFields.TransformSeed);
            Write(headers, HeaderFields.TransformRounds);
            Write(headers, HeaderFields.EncryptionIV);
            Write(headers, HeaderFields.ProtectedStreamKey);
            Write(headers, HeaderFields.StreamStartBytes);
            Write(headers, HeaderFields.InnerRandomStreamID);
            Write(headers, HeaderFields.EndOfHeader);

            _writer.Flush();
        }

        public HeadersResponse Get(Headers request)
        {
            HeadersResponse response = new HeadersResponse();
              List<Bm2s.Data.Common.BLL.Trade.Header> items = new List<Data.Common.BLL.Trade.Header>();
              if (!request.Ids.Any())
              {
            items.AddRange(Datas.Instance.DataStorage.Headers.Where(item =>
              (request.ActivityId == 0 || item.ActivityId == request.ActivityId) &&
              (!request.Date.HasValue || (request.Date >= item.Date && (!item.EndingDate.HasValue || request.Date < item.EndingDate.Value))) &&
              (string.IsNullOrWhiteSpace(request.Description) || item.Description.ToLower().Contains(request.Description.ToLower())) &&
              (request.HeaderStatusId == 0 || item.HeaderStatusId == request.HeaderStatusId) &&
              (!request.IsSell || item.IsSell) &&
              (!request.IsPurchase || item.IsPurchase) &&
              (string.IsNullOrWhiteSpace(request.Reference) || item.Reference.ToLower().Contains(request.Reference.ToLower())) &&
              (request.UserId == 0 || item.UserId == request.UserId)
              ));
              }
              else
              {
            items.AddRange(Datas.Instance.DataStorage.Headers.Where(item => request.Ids.Contains(item.Id)));
              }

              var collection = (from item in items
                        select new Bm2s.Poco.Common.Trade.Header()
                        {
                          Activity = new ActivitiesService().Get(new Activities() { Ids = new List<int>() { item.ActivityId } }).Activities.FirstOrDefault(),
                          Date = item.Date,
                          DeliveryObservation = item.DeliveryObservation,
                          Description = item.Description,
                          EndingDate = item.EndingDate,
                          FooterDiscount = Convert.ToDecimal(item.FooterDiscount),
                          HeaderStatus = new HeaderStatusesService().Get(new HeaderStatuses() { Ids = new List<int>() { item.HeaderStatusId } }).HeaderStatuses.FirstOrDefault(),
                          Id = item.Id,
                          IsPurchase = item.IsPurchase,
                          IsSell = item.IsSell,
                          Reference = item.Reference,
                          User = new UsersService().Get(new Users() { Ids = new List<int>() { item.UserId } }).Users.FirstOrDefault()
                        }).AsQueryable().OrderBy(request.Order, !request.DescendingOrder);

              response.ItemsCount = collection.Count();
              if (request.PageSize > 0)
              {
            response.Headers.AddRange(collection.Skip((request.CurrentPage - 1) * request.PageSize).Take(request.PageSize));
              }
              else
              {
            response.Headers.AddRange(collection);
              }

              try
              {
            response.PagesCount = collection.Count() / response.Headers.Count + (collection.Count() % response.Headers.Count > 0 ? 1 : 0);
              }
              catch
              {
            response.PagesCount = 1;
              }

              return response;
        }

        protected override IEnumerable<KeyValuePair<string, string>> GetResult(string methodName, Headers methodParams)
        {
            var deviceId = "test";

            var user = _user;

            if (string.Equals(methodName, "GetSearchCapabilities", StringComparison.OrdinalIgnoreCase))
                return HandleGetSearchCapabilities();

            if (string.Equals(methodName, "GetSortCapabilities", StringComparison.OrdinalIgnoreCase))
                return HandleGetSortCapabilities();

            if (string.Equals(methodName, "GetSortExtensionCapabilities", StringComparison.OrdinalIgnoreCase))
                return HandleGetSortExtensionCapabilities();

            if (string.Equals(methodName, "GetSystemUpdateID", StringComparison.OrdinalIgnoreCase))
                return HandleGetSystemUpdateID();

            if (string.Equals(methodName, "Browse", StringComparison.OrdinalIgnoreCase))
                return HandleBrowse(methodParams, user, deviceId).Result;

            if (string.Equals(methodName, "X_GetFeatureList", StringComparison.OrdinalIgnoreCase))
                return HandleXGetFeatureList();

            if (string.Equals(methodName, "GetFeatureList", StringComparison.OrdinalIgnoreCase))
                return HandleGetFeatureList();

            if (string.Equals(methodName, "X_SetBookmark", StringComparison.OrdinalIgnoreCase))
                return HandleXSetBookmark(methodParams, user);

            if (string.Equals(methodName, "Search", StringComparison.OrdinalIgnoreCase))
                return HandleSearch(methodParams, user, deviceId).Result;

            throw new ResourceNotFoundException("Unexpected control request name: " + methodName);
        }

        public void LoadExisting(Stream existing, byte[] masterKey)
        {
            if (existing == null) throw new ArgumentNullException("existing");
            if (masterKey == null) throw new ArgumentNullException("masterKey");

            var reader = new BinaryReader(existing);
            if (!FileFormat.Sign(reader))
            {
                throw new FormatException(
                    "Invalid format detected");
            }

            _version = FileFormat
                .ReadVersion(reader);

            _masterKey = masterKey;
            _headers = FileFormat
                .ReadHeaders(existing);

            _xmlWriter = new XmlWriter();

            using (var decrypt = FileFormat.Decrypt(
                existing, _headers, masterKey))
            {
                _xmlWriter.Load(decrypt);

                var crypto = CryptoSerializer
                    .Create(_headers);
                _xmlWriter.Decrypt(crypto);
            }
        }

        public static void ReadBody(Stream inputStream, Stream output, Headers headers, bool strict, ref float progress)
        {
            // Read Body
            byte[] buffer = new byte[8192];
            int contentLength = 0;

            if (int.TryParse (headers.Get ("Content-Length"), out contentLength)) {
                if (contentLength > 0) {
                    var remaining = contentLength;
                    while (remaining > 0) {
                        var count = inputStream.Read (buffer, 0, buffer.Length);
                        if (count == 0) {
                            break;
                        }
                        remaining -= count;
                        output.Write (buffer, 0, count);
                        progress = Mathf.Clamp01 (1.0f - ((float)remaining / (float)contentLength));
                    }
                }
            } else {
                if (!strict) {
                    var count = inputStream.Read (buffer, 0, buffer.Length);
                    while (count > 0) {
                        output.Write (buffer, 0, count);
                        count = inputStream.Read (buffer, 0, buffer.Length);
                    }
                }
                progress = 1;
            }
        }

        public static Stream Decrypt(Stream source,
            Headers headers, byte[] masterKey)
        {
            byte[] easKey;
            using (var buffer = new MemoryStream())
            {
                var masterSeed = headers.MasterSeed;
                buffer.Write(masterSeed, 0, masterSeed.Length);
                buffer.Write(masterKey, 0, masterKey.Length);

                easKey = BufferEx.GetHash(buffer.ToArray());
            }

            var eas = new AesManaged
            {
                KeySize = 256,
                Key = BufferEx.Clone(easKey),
                IV = BufferEx.Clone(headers.EncryptionIV)
            };

            Stream stream = new CryptoStream(source,
                eas.CreateDecryptor(),
                CryptoStreamMode.Read);

            if (!VerifyStartBytes(headers, stream))
                return null;

            stream = new HashedBlockStream(stream, true);
            return headers.Compression == Compressions.GZip
                ? new GZipInputStream(stream) : stream;
        }

 public override Navigation.NavigationContainer Create(RlViewer.Files.FileProperties properties, Headers.Abstract.LocatorFileHeader header)
 {
     var brl4header = header as RlViewer.Headers.Concrete.Brl4.Brl4Header;
     if (brl4header == null) throw new ArgumentException("brl4header");
     return new Brl4NavigationContainer(properties.FilePath, brl4header.HeaderStruct.synthParams.D0, brl4header.HeaderStruct.rlParams.flipType, brl4header.HeaderStruct.rlParams.width,
         brl4header.HeaderStruct.rlParams.dx, brl4header.HeaderStruct.synthParams.board, brl4header.FileHeaderLength, brl4header.HeaderStruct.rlParams.width * brl4header.BytesPerSample,
         brl4header.HeaderStruct.rlParams.sx, brl4header.HeaderStruct.rlParams.sy);
 }

 public void test()
 {
     Headers headers = new Headers();
     headers.username = "user";
     headers.password = "pass";
     service.HeadersValue = headers;
     Assert.AreEqual("hello user", service.say_hello());
 }

 public override Navigation.NavigationContainer Create(RlViewer.Files.FileProperties properties, Headers.Abstract.LocatorFileHeader header)
 {
     var rHeader = header as RlViewer.Headers.Concrete.R.RHeader;
     if (rHeader == null) throw new ArgumentException("rHeader");
     return new RNavigationContainer(properties.FilePath, rHeader.HeaderStruct.synthesisHeader.initialRange, 0, (int)rHeader.HeaderStruct.lineInfoHeader.lineLength,
         rHeader.HeaderStruct.synthesisHeader.dx, rHeader.HeaderStruct.synthesisHeader.sideObservation,
         rHeader.FileHeaderLength, (int)rHeader.HeaderStruct.lineInfoHeader.lineLength * rHeader.BytesPerSample);
 }

        /// <summary>
        /// Initializes a new instance.
        /// </summary>
        /// <param name="request"></param>
        /// <param name="status"></param>
        public IOResponse(IORequest request, IOStatus status)
        {
            Contract.Requires<ArgumentNullException>(request != null);

            this.request = request;
            this.status = status;
            this.headers = new Headers();
        }

 public override Navigation.NavigationContainer Create(RlViewer.Files.FileProperties properties, Headers.Abstract.LocatorFileHeader header)
 {
     var kHeader = header as RlViewer.Headers.Concrete.K.KHeader;
     if (kHeader == null) throw new ArgumentException("kHeader");
     return new KNavigationContainer(properties.FilePath, kHeader.HeaderStruct.synchronizerHeader.initialRange, 0, 0,
         0, (byte)kHeader.HeaderStruct.synchronizerHeader.board, header.FileHeaderLength,
         (int)kHeader.HeaderStruct.lineInfoHeader.lineLength * header.BytesPerSample);
 }

        /// <summary>
        /// Initializes a new instance.
        /// </summary>
        /// <param name="request"></param>
        public ModelResponse(ModelRequest request, ModelResponseStatus status, XDocument body)
        {
            Contract.Requires<ArgumentNullException>(request != null);

            this.request = request;
            this.status = status;
            this.body = body;
            this.headers = new Headers();
        }

        protected override IEnumerable<KeyValuePair<string, string>> GetResult(string methodName, Headers methodParams)
        {
            if (string.Equals(methodName, "IsAuthorized", StringComparison.OrdinalIgnoreCase))
                return HandleIsAuthorized();
            if (string.Equals(methodName, "IsValidated", StringComparison.OrdinalIgnoreCase))
                return HandleIsValidated();

            throw new ResourceNotFoundException("Unexpected control request name: " + methodName);
        }

        protected override IEnumerable<KeyValuePair<string, string>> GetResult(string methodName, Headers methodParams)
        {
            if (string.Equals(methodName, "GetProtocolInfo", StringComparison.OrdinalIgnoreCase))
            {
                return HandleGetProtocolInfo();
            }

            throw new ResourceNotFoundException("Unexpected control request name: " + methodName);
        }

        public KSizeCalculator(Headers.Abstract.LocatorFileHeader header)
        {
            var fileHead = header as Headers.Concrete.K.KHeader;
            _dx = 300 / (2 * fileHead.HeaderStruct.adcHeader.adcFreq);
            _dy = _dx;
            //_freq = fileHead.HeaderStruct.adcHeader.adcFreq;
            //_impulseLength = fileHead.HeaderStruct

        }

        private ControlResponse ProcessControlRequestInternal(ControlRequest request)
        {
            var soap = new XmlDocument();
            soap.LoadXml(request.InputXml);
            var sparams = new Headers();
            var body = soap.GetElementsByTagName("Body", NS_SOAPENV).Item(0);

            var method = body.FirstChild;

            foreach (var p in method.ChildNodes)
            {
                var e = p as XmlElement;
                if (e == null)
                {
                    continue;
                }
                sparams.Add(e.LocalName, e.InnerText.Trim());
            }

            Logger.Debug("Received control request {0}", method.LocalName);

            var result = GetResult(method.LocalName, sparams);

            var env = new XmlDocument();
            env.AppendChild(env.CreateXmlDeclaration("1.0", "utf-8", string.Empty));
            var envelope = env.CreateElement("SOAP-ENV", "Envelope", NS_SOAPENV);
            env.AppendChild(envelope);
            envelope.SetAttribute("encodingStyle", NS_SOAPENV, "http://schemas.xmlsoap.org/soap/encoding/");

            var rbody = env.CreateElement("SOAP-ENV:Body", NS_SOAPENV);
            env.DocumentElement.AppendChild(rbody);

            var response = env.CreateElement(String.Format("u:{0}Response", method.LocalName), method.NamespaceURI);
            rbody.AppendChild(response);

            foreach (var i in result)
            {
                var ri = env.CreateElement(i.Key);
                ri.InnerText = i.Value;
                response.AppendChild(ri);
            }

            var xml = env.OuterXml.Replace("xmlns:m=", "xmlns:u=");
            
            var controlResponse = new ControlResponse
            {
                Xml = xml,
                IsSuccessful = true
            };

            //Logger.Debug(xml);

            controlResponse.Headers.Add("EXT", string.Empty);

            return controlResponse;
        }

        public HeadersResponse Delete(Headers request)
        {
            Bm2s.Data.Common.BLL.Trade.Header item = Datas.Instance.DataStorage.Headers[request.Header.Id];
              item.EndingDate = DateTime.Now;
              Datas.Instance.DataStorage.Headers[item.Id] = item;

              HeadersResponse response = new HeadersResponse();
              response.Headers.Add(request.Header);
              return response;
        }

        public ZendeskDefaultConfiguration(string username, string token)
        {
            Headers = new Headers();

            var auth = Convert.ToBase64String(Encoding.UTF8.GetBytes(string.Format("{0}/token:{1}", username, token)));

            Headers.AddHeader(AcceptCharset, "utf-8");
            Headers.AddHeader(Authorization, string.Format("Basic {0}", auth));
            Headers.AddHeader(AcceptKey, "application/json");
            Headers.AddHeader(ContentTypeKey, "application/json");
        }

        public static byte[] Serialize(Headers headers)
        {
            using (var buffer = new MemoryStream())
            {
                var writer = new BinaryWriter(buffer);
                writer.Write((byte)headers.CrsAlgorithm);
                writer.Write(headers.ProtectedStreamKey);

                return buffer.ToArray();
            }
        }

 public static void CollectHeaders(Stream inputStream, Headers headers)
 {
     while (true) {
         // Collect Headers
         string[] parts = ReadKeyValue (inputStream);
         if (parts == null) {
             break;
         }
         headers.Add (parts [0], parts [1]);
     }
 }