[Question]
  [
## The challenge
Well, I think it is quite clear, isn't it? You have to make a function or a program that takes a string as an argument and outputs the corrispondent Yoda-speaking.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so least number of bytes wins.
## The input
The input could be **any** string without linefeed. You can translate a string if it is composed like this:
*Subject* + Verb + Something else.
Where *Subject* is a personal pronoun (I, you, he, she, it, we, they). You don't have to recognize that the second word is a verb.
If the first word isn't a pronoun, the input is valid but the output will be `Too difficult, this sentence is.`
```
You have to win this code challenge -> Translatable
Luke has to win this code challenge -> Untranslatable
```
Input can end with a letter, a . or a !, not with a ?.
Furthermore, strings can contain Non-Ascii, Parenthesis, commas, colons ...
## The output
In case of a translatable sentence, the output is the same sentence, with the subject and the verb at the end of the sentence.
```
You have to win this code challenge -> To win this code challenge, you have.
```
Comma, period and lower-case on the pronoun are mandatory. (Except, of course, if the pronoun is I).
As stated before, if it is untranslatable you have to output the string `Too difficult, this sentence is.`
## Examples
```
You have to win this code challenge -> To win this code challenge, you have.
He won this code challenge -> This code challenge, he won.  (I know this is not yoda-speaking, but I don’t want to overcomplicate this challenge)
I ate an ice cream earlier! -> An ice cream earlier, I ate.
I liked the Star Wars original trilogy more than the prequel’s one. -> The Star Wars original trilogy more than the prequel’s one, I liked.
I find your lack of faith disturbing -> Your lack of faith disturbing, I find.
I think we are done with the examples -> We are done with examples, I think.
He is your son, Vader -> Your son, Vader, he is.
I think they’ll add new features -> They’ll add new features, I think.
I made a fantastic code challenge (I hope) -> A fantastic code challenge (I hope), I made.
I love constants like π -> Constants like π, I love.
I’ll be the next President, I swear! -> Too difficult, this sentence is.
This challenge is great! -> Too difficult, this sentence is.
Is this challenge great? -> Too difficult, this sentence is.
Luke is not ready for this task -> Too difficult, this sentence is.
Somebody loves constants like π -> Too difficult, this sentence is.
[Empty string] -> Too difficult, this sentence is.
```
  
[Answer]
# Retina, ~~162~~ ~~137~~ ~~145~~ ~~134~~ ~~131~~ 129
Multiple punctuation is now handled correctly. Test case: `You will not win this challenge...! -> Not win this challenge..., you will.`
[Try it Online!](http://retina.tryitonline.net/#code=Wy4hXSQKClRgQS1aYGEtemBeXHdcdwpHYF4oSXx3ZXx5b3V8cz9oZXxpdHx0aGV5KSBcUysgXFMKKFxTKyBcUyspICguKikKJDIsICQxLgpUYGEtemBBLVpgXi4KXiQKVG9vIGRpZmZpY3VsdCwgdGhpcyBzZW50ZW5jZSBpcy4&input=WW91IHdpbGwgbm90IHdpbiB0aGlzIGNoYWxsZW5nZS4uLiE)
```
[.!]$
T`A-Z`a-z`^\w\w
G`^(I|we|you|s?he|it|they) \S+ \S
(\S+ \S+) (.*)
$2, $1.
T`a-z`A-Z`^.
^$
Too difficult, this sentence is.
```
Description:
If there is punctuation in the end, delete it.
```
[.!]$
^empty line
```
Transform the pronoun to lower case, except it is I.
```
T`A-Z`a-z`^\w\w
```
Filter out any line that does not match `<Pronoun><space><word><space><word>...`
```
G`^(I|we|you|s?he|it|they) \S+ \S
```
Split into `pronoun + verb`, `remainder`. Then rearrange.
```
(\S+ \S+) (.*)
$2, $1.
```
Transform the first character to upper case.
```
T`a-z`A-Z`^.
```
If the result is empty, it didn't pass the filter above. Print an error message.
```
^$
Too difficult, this sentence is.
```
[Answer]
# ES6, 212
This can probably a bit further golfed down:
```
i=>(r=/(you|s?he|it?|we|they)( \S+) ([^\.!?]+)/i.exec(i))?(c=(a,b)=>a[`to${['Low','Upp'][b]}erCase`]())(r[3].slice(0,1),1)+r[3].slice(1)+", "+c(r[1],+(/i/i.test(r[1])))+r[2]+".":"Too difficult, this sentence is."
```
[JSFiddle](https://jsfiddle.net/uLrbyqg0/1/) (requires up-to-date browser like Chrome) or run it via node.js
Ungolfed:
```
i=>{
    r=/(you|s?he|it?|we|they)( \S+) ([^\.!?]+)/i.exec(i); //Main RegExp
    c=(a,b)=>a[`to${['Low','Upp'][b]}erCase`](); //shortcut for toUpperCase/toLowerCase
    if (r)
        return c(r[3].slice(0,1),1)+r[3].slice(1) + ", " //the "something else", properly formated
             + c(r[1], +(/i/i.test(r[1]))) //The subject lowercased except for "i" or "I"
             + r[2] + "."; //The End
    else //no match, no sentence to translate
        return "Too difficult, this sentence is.";
}
```
[Answer]
# JavaScript (ES6), 164 bytes
```
s=>([,p,,i,r]=s.match`^(((I)|You|He|She|It|We|They) \\S+) (.*?)[.!]?$`)?r[0].toUpperCase()+r.slice(1)+`, ${i?p:p.toLowerCase()}.`:"Too difficult, this sentence is."
```
## Explanation
It's almost painful how many bytes capitalising the first letter of a string takes in JavaScript...
```
s=>
  // Match and get specific parts of the input string
  ([,p,,i,r]=s.match`^(((I)|You|He|She|It|We|They) \\S+) (.*?)[.!]?$`)?
    r[0].toUpperCase()+r.slice(1)     // capitalise first letter
      +`, ${i?p:p.toLowerCase()}.`    // lower-case the pronoun (unless it is I)
  :"Too difficult, this sentence is."
```
## Test
Test does not use destructuring assignment to make it more cross-browser compatible.
```
var solution = s=>(p=s.match`^(((I)|You|He|She|It|We|They) \\S+) (.*?)[.!]?$`)?p[4][0].toUpperCase()+p[4].slice(1)+`, ${p[3]?p[1]:p[1].toLowerCase()}.`:"Too difficult, this sentence is."
```
```
<input type="text" id="input" value="I love constants like π...!" />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>
```
[Answer]
## Python, 261 bytes
```
import re
def a(b):
 if b[-1:]in".!":
  b=b[:-1]
 if re.match('(I|YOU|S?HE|IT|WE|THEY) \w+ \S+',b.upper()):
  b=(b+',').split()
  if b[0]!="I":
   b[0]=b[0].lower()
  b=" ".join(b[2:]+b[:2])
  return b[0].upper()+b[1:]
 return "Too difficult, this sentence is."
```
Turns out Python doesn't mind things like `b[-1]in".!"` Next I'll play with the match object more, if no-one beats me to it :)
[Answer]
# Python, ~~218~~ ~~217~~ 204 bytes
Not sure if this can be further golfed down.
```
def f(s):t=s.split();u=' '.join(t[2:]).rstrip('!.');return['Too difficult, this sentence is.','%s, %s %s.'%(u[0].upper()+u[1:],['I',t[0].lower()][t[0]!='I'],t[1])][t[0]in'I We You He She It They'.split()]
```
Ungolfed:
```
def f(s):
    t = s.split()
    u = ' '.join(t[2:]).rstrip('!.')
    return [
        'Too difficult, this sentence is.',
        '%s, %s %s.' % (u[0].upper() + u[1:],
                        ['I', t[0].lower()][t[0] != 'I'],
                        t[1])
    ][t[0] in 'I We You He She It They'.split()]
```
[Answer]
# GNU sed, 129 bytes
I'm including +1 byte for the `-r` flag.
```
#!/bin/sed -rf
/^I /b
s/^(You|[HW]e|She|It|They) /\L&/
t
s/.*/Too difficult, this sentence is./p
d
:
s/[.!]$//
s/^([^ ]+ [^ ]+) (.*)/\u\2, \1./
```
### Explanation
If we match a leading `I` we jump to the label:
```
/^I /b
```
If we match one of the other pronouns, we downcase it, then jump to the label:
```
s/^(You|[HW]e|She|It|They) /\L&/
t
```
Otherwise we print the failure message and move to the next input line:
```
s/.*/Too difficult, this sentence is./p
d
```
If we jumped to the label, we remove any final punctuation:
```
:
s/[.!]$//
```
and swap the first two words with the rest of the sentence, capitalising the new first word and adding the required punctuation as we do so:
```
s/^([^ ]+ [^ ]+) (.*)/\u\2, \1./
```
]