Making strIndex total in Quick Search?

Question

I am working on a version of the Quick Search string searching algorithm in Idris, and have come up with this:

quickSearch : (needle       : String) ->
              (haystack     : String) ->
              {auto lengths : (length needle) `LTE` (length haystack)} ->
              Maybe Nat
quickSearch needle haystack = let n = length needle in
                              let h = length haystack in
                                  go (makeBadShift needle) n (h - n)
  where
    go : (badShift : CharShift) ->
         (n        : Nat) ->
         (last     : Nat) ->
         Maybe Nat
    go badShift n last = go' 0
      where
        go' : Nat -> Maybe Nat
        go' i = if i > last then Nothing
                else if (substr i n haystack) == needle then Just i
                else if i == last then Nothing
                else let ch = strIndex haystack (cast (n + i)) in
                     let shift = lookupChar badShift ch in
                         go' (i + shift)

(lookupChar and makeBadShift are elsewhere.)

This works fine, but I wanted to make it more formally correct. To start with, it's not total due to the use of strIndex. It's not hard to create a total version of strIndex (either going through List Char or this:)

strIndex' : (str : String) ->
            (n : Nat) ->
            {auto ok : (n `LT` (Strings.length str))} ->
            Char
strIndex' str n = assert_total $ prim__strIndex str (cast n)

but then I have to have a way of proving that (n + i) is less than h. (It is, because at that point i < h - n.)

If I directly replace the ">" and "==" with their proof-bearing cousins, I wind up looking at negations:

iNEQlast : (i = last) -> Void

and

iNGTlast : (S last) `LTE` i -> Void

which left me stumped.

On the other hand, I can reverse the conditions, ending up with

"quicksearch.idr" 115L, 4588C written
  needle : String
  haystack : String
  lengths : LTE (fromIntegerNat (prim__zextInt_BigInt (prim_lenString needle))) (fromIntegerNat (prim__zextInt_BigInt (prim_lenString haystack)))
  badShift : CharShift
  n : Nat
  h : Nat
  nh : LTE n h
  i : Nat
  iLTlast : LTE (S i) (minus h n)
  iLTElast : LTE i (minus h n)
--------------------------------------
go'_rhs_1 : Maybe Nat

but at this point I'm thoroughly confused and don't know how to go forward.

What is the best thing to do now?