////////////////////////////////////////////////////////////////////////////////
//
//  Microsoft Research Singularity
//
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//
//  File:   SbUtils.cs
//          StringBuilder Utility Class
//  Note:
//

using System;
using System.Text; 
using Microsoft.Singularity.Channels;

#if !SINGULARITY_PROCESS 
namespace Microsoft.Singularity.Directory
#else
using Microsoft.Singularity;
using Microsoft.Singularity.V1.Services;
namespace Microsoft.Application.DSP
#endif 
{
    public class SbUtils
    {
        private const char delimiter = '/'; 

        public static bool IsTail(StringBuilder! sb) 
        {
            if (sb.Length <= 1) return false; 
            int pos = IndexOf(sb,delimiter,1); 
            if (pos == -1) return true; 
            return false; 
        }
        public static int IndexOf (StringBuilder! sb, char theChar, int startPos)
        {
            if (sb.Length == 0) return 0; 
            for (int i = startPos ; i < sb.Length;  i++) {
                if (sb[i] == theChar) return i; 
            }
            return -1; 
        }

        public static int LastIndexOf (StringBuilder! sb, char theChar, int startPos)
        {
            if (sb.Length == 0) return 0; 
            for (int i = sb.Length ; i > startPos+1 ; i--) {
                if (sb[i-1] == theChar) return i; 
            }
            return -1; 
        }

        public static bool Empty (StringBuilder! sb) 
        { 
            if ( sb.Length > 0) {
                return true; 
            }
            else {
                return false; 
            }
        }

        public int Length(StringBuilder! sb)
        {
            return sb.Length;
        }

        public static StringBuilder! StripLast(StringBuilder! sb)
        {
            int pos = LastIndexOf(sb,delimiter,0); 
            if (pos == -1) {
                sb.Length = 1;  // just the delimiter
            }
            else if ( (pos+1) < sb.Length ) {
                sb.Length = pos-1; 
            }
            else {
                sb.Length = 0; 
            }
            return sb; 
        }
        
       
        public static StringBuilder! RemoveFirstElement(StringBuilder! sb, out int charCount)
        {
            return StripFirst(sb, out charCount); 
        }
        
        public static StringBuilder! StripFirst(StringBuilder! sb, out int charCount)
        {
            charCount = 0; 
            if ( sb[0] == delimiter){
                charCount = 1;
                int pos = IndexOf(sb, delimiter,1);  // just in case it starts with '/'
                if (  (pos >= 0) && (pos < sb.Length ) ) {
                    charCount = pos; 
                    sb.Remove(0,pos); 
                    return sb;
                }
                charCount = sb.Length;
                sb.Length = 0; 
                return sb; 
            }
            else {
                int pos = IndexOf(sb,delimiter,0);  // just in case it starts with '/'
                if (  (pos >= 0) && (pos < sb.Length ) ){
                    charCount = pos; 
                    sb.Remove(0,pos); 
                    return sb; 
                }
                charCount = sb.Length;
                sb.Length = 0; 
                return sb; 
            }
       }

        public static void Append(StringBuilder! sb, String! elt)
        {
            sb.Append(elt);
        }

        // Return a st
        //
        public static String FirstElement(StringBuilder! sb)
        {
            if (sb.Length == 0) return null; 
            
            if ( sb[0] == delimiter){
                int pos = IndexOf(sb,delimiter,1);  
              
                // DebugStub.WriteLine("  FindFirst:pos={0},len={1},s={2}",__arglist(pos,sb.Length,sb.ToString())); 
                //DebugStub.Break(); 
                if (pos == -1) {
                    if (sb.Length == 1) return null;  // just the delimiter 
                    return sb.ToString(1,sb.Length-1); 
                }
                if (  (pos > 1) && (pos < sb.Length ) ) {
                    return sb.ToString(1,pos-1); 
                }
                return null; 
            }
            else {
                int pos = IndexOf(sb,delimiter,0); 
                if (pos == -1) {
                    return sb.ToString(); 
                }
                if ( (pos < sb.Length) && (pos > 0) ){
                    return sb.ToString(0,pos); 
                }
                return null; 
            }
        }

        public static String PathString(StringBuilder! sb)
        {
            if (sb.Length == 0 ) return null; 
            return sb.ToString(); 
        }

        public static char[]! in ExHeap PathVector(StringBuilder! sb)
        {
            return Bitter.FromString2(sb.ToString());
        }
    }
}