Python 3.8, 56 bytes

lambda a,b:(x:=a[:b].split(' '))and[len(x[-1]),len(x)-1]

Try it online!

Perl 5, 47 44 bytes

$_=substr$_,0,<>;/.* /;$_=$'=~y///c.$".y/ //

• 
  $_=substr$_,0,<>; to extract first n (from nextline <>) characters of input $_ and store in default argument.


• 
  /.* / to match largest string ending with space


• 
  $_=$'=~y///c.$".y/ // default argument $_ (which will be printed -p option) is set with concatenation . of length of post-match : $'=~y///c, $" space (list argument delimiter when interpolated betwen double quotes), and y/ // number of spaces in current default argument.

TIO

05AB1E, 9 bytes

£ð¡¤gsg<‚

Port of @JonasAusevicius's Python 3.8 answer, so make sure to upvote him as well!

Try it online or verify all test cases.

Explanation:

£ # Only leave the first (implicit) input-integer amount of characters
 # of the (implicit) string-input
 ð¡ # Split this by spaces
 # (Note: builtin `#` doesn't work here, because a string without spaces
 # would not be wrapped in a list)
 ¤g # Get the length of the last string in the list (without popping the list itself)
 sg< # Swap to get the list again, and get it's length minus 1
 ‚ # Pair both integers (and output the result implicitly)

JavaScript (Node.js), 75 70 69 70 68 bytes

(t,o)=>[o+~(s=t.substr(0,o)).lastIndexOf(' '),s.split(' ').length-1]

Try it online!

No space parameter, only hardcoded (+ 2 bytes)

-2 bytes thanks to inspiration from the Java answer by Kevin Cruijssen

C# (Visual C# Interactive Compiler), 79 77 75 63 60 bytes

a=>b=>((a=a.Substring(0,b).Split())[b=a.Length-1].Length,b);

8 bytes saved thanks to Kevin Cruijssen and a further 3 bytes saved thanks to Embodiment of Ignorance

Try it online!

Stax, 5 bytes

╓ò)♣*

Run and debug it

Unpacked, ungolfed, and commented, it looks like this.

( trim string to length
j split on spaces
N remove last element from array and push separately
W until the stack is empty...
 %P pop element and print its length

Run this one

APL+WIN, 33 bytes

(1++/m),n-¯1↑(m←(m←n↑⎕)=' ')/⍳n←⎕

Try it online! Courtesy of Dyalog Classic

1 Indexed

Prompts for index of character in full text string followed by string

Outputs index of character in nth substring and substring number

Java 8, 83 75 bytes

n->s->n+~(s=s.substring(0,n)).lastIndexOf(" ")+","+~-s.split(" ",-1).length

-8 bytes implicitly thanks to inspiration from @yunzen's JavaScript answer.

Try it online.

Explanation:

n->s-> // Method with integer & String parameters and String return-type
 n+~ // Return `n` minus 1, minus the following:
 (s=s.substring(0,n))// Set `s` to the first `n` characters of input-String `s`
 .lastIndexOf(" ") // and get the index of the last space
 +"," // Appended with a comma-delimiter
 s.split(" ", // Split the new `s` by spaces
 -1) // and keep empty trailing items
 +~- ... .length // And append the amount of items minus 1 to the result

Jelly, 7 bytes

ḣḲẈṪ,LƊ

A dyadic Link accepting a list of characters on the left and the 0-indexed index on the right which yields a list of integers, [character, word], again 0-indexed.

Try it online!

JavaScript (ES6), 56 bytes

Takes input as (offset)(string).

n=>g=([c,...a],b=i=0)=>n--?g(a,b+!(i+=c!=' '||-i)):[i,b]

Try it online!

Commented

n => // n = desired offset in string
 g = ( // g = recursive function taking:
 [c, ...a], // c = current character; a[] = array of remaining characters
 b = // b = index of current block
 i = 0 // i = current position within the current block
 ) => //
 n-- ? // if we haven't reached the desired offset: 
 g( // do a recursive call to g:
 a, // pass the array of remaining characters
 b + !( // update b:
 i += // update i:
 c != ' ' // increment i if the current character is not a space
 || -i // or set i to zero if it is
 ) // increment b if i was set to zero, or leave it unchanged otherwise
 ) // end of recursive call
 : // else:
 [i, b] // stop recursion and return [i, b]

Bash, 66 bytes

z=$(echo $i:0:o);echo $z|sed 's/^.* //g'|wc -c;set -- $z;echo $#

1-indexed. $i contains the input, and $o contains the offset

Explanation:

z=$(echo $LDS:0:o); # delete the rest of the word
echo $z|sed 's/^.* //g'|wc -c; # remove anything up to the last word, and count what's left.
set -- $z;echo $# # find the number of words after the stuff after the offset is deleted

Charcoal, 14 bytes

≔⪪…ＳＮ θＩ⟦Ｌ⊟θＬθ

Try it online! Link is to verbose version of code. Explanation:

≔⪪…ＳＮ θ

Truncate the input string to the given length and split on spaces.

Ｉ⟦Ｌ⊟θＬθ

Extract the last string and take its length, then take the number of remaining strings, cast both lengths to string and implicitly print them on separate lines.

Retina 0.8.2, 50 bytes

^.+
$*
^(1)*¶((?<-1>.)*).*
$2
^(.*? )*(.*)
$.2,$#1

Try it online! Takes input in the order offset, string. Explanation:

^.+
$*

Convert the offset to unary.

^(1)*¶((?<-1>.)*).*
$2

Truncate the string to the given length. This uses .NET's balancing groups to count the same number of characters in each string.

^(.*? )*(.*)
$.2,$#1

Count the number of spaces and the number of characters after the last space and output them in decimal in reverse order.