Is this a valid Tichu play? Tichu is a card game in which players take turn playing sets of cards from a deck consisting of a standard 52-card deck, plus 4 additional cards:


the dragon, which has a greater value than any other card
the phoenix, which can act as a wildcard
the dog, which passes the turn to your partner
the Mah Jong, which has value 1 (and the person holding it plays first)


The first player (who is said to have "lead") can choose to play one of the following types of card combinations:


a single (e.g. 6)
a pair (JJ)
a triple (555)
a full house (QQQ33) - a triple and a pair
a straight (56789) - 5 or more consecutive cards
a tractor (223344) - any consecutive sequence of pairs


Subsequent players are then only allowed to play a set of cards of the same type, but strictly higher. For example, QQ can be played on top of JJ, but QQKK cannot (it is a tractor, not a pair). Full houses are ordered by the triple (e.g. 77722 > 44499), and straights and tractors must be the same length (456789 cannot be played on top of 23456). Aces are high.

There is one exception: any 4 of the same card is a bomb, and can be played on top of anything except a higher bomb.1

The dragon can be played by itself on top of any single or with lead (but nowhere else). The phoenix, aside from being a wildcard, can also be played on top of any single except the dragon.2 The dog can only be played by itself with lead and immediately ends the turn.3



Your challenge is to determine whether a given Tichu play is valid, given the previous play.

You may accept both plays in any order as either lists of integers or strings -- in either case, you may choose any mapping of cards to integers/characters.
If there was a previous play, it will always be valid, and if not (i.e. the player has lead), the first input will be the empty array/string (matching the type of the other input). The cards are not guaranteed to be given in any particular order.

Your output must be selected from a set of exactly two distinct values, one of which indicates the play is legal and one that indicates it is not.

There is no need to test for whether the set of cards actually exists in the deck (e.g. 77766 followed by 88877 is impossible because there are only four 7's) -- such cases will never be given.

In the following test cases, 234567890JQKA represent 2 through ace, and RPD1 represent the dragon, phoenix, dog, and Mah Jong respectively. The empty string is shown here as -. These plays are legal:

6 J
JJ QQ
555 KKK
44499 77722
23456 56789
223344 QQKKAA
49494 72727
A R
A P
P R
66 7P
P6 77
58304967 6P0594J7
5P304967 680594J7
57446765 788657P5
- D
- 1
- 12345
3344556677889900 JJJJ
5555 7777


And these are not:

9 3
66 55
888 444
44 888
77722 44499
44499 777
44499 777JJJ
45678 34567
34567 456789
556677 334455
5566 778899
72727 49494
A A
R A
R P
77 RP
77 6P
P7 66
680594J7 5P304967
6P0594J7 58304967
57446765 3645P536
1 D
2 D
2 1
- 1234
7777 5555
- 223355




1: actually, a straight flush is also a bomb, but since this is the only place in the game that the suit of the cards matter, I have chosen to leave it out for simplicity's sake

2: the value of the phoenix played on top of a card with value n is actually n+0.5 (a phoenix on a 9 is a 9 and a half); since this requires knowledge of additional history to adjudicate, no test cases involve a single played on top of a single phoenix

3: so the first input will never be dog
JavaScript (ES6),  274  273 bytes
Takes input as (a)(b), where \$a\$ and \$b\$ are arrays of integers with:

\$1\$ = dog
\$3\$ = Mah Jong
\$4..16\$ = 2 ... Ace
\$18\$ = dragon
\$19\$ = phoenix

Returns false for valid or true for invalid.
a=&gt;b=&gt;!(L='length',[A,B]=(g=a=&gt;(h=n=&gt;--n?[i=1,2,3,'(20*)3|30*2','1{5,}','22+',4].some(p=&gt;m=o.join``.match(`9(0*)(${p})0*$`,i++),a.map(x=&gt;o[x-19?x:x=n]=-~o[x],o=[...9e16+'']))?[i,m[1][L]+(m[3]||[])[L]]:h(n):[])(18))(a),[C,D]=g(b),a+a?A-C?C&gt;7|+b&gt;a:a[L]==b[L]&amp;D&gt;B|A&lt;3&amp;b==18:C)

Try it online!
How?
To evaluate a hand, we build an array o[] made of a leading \$9\$, initially followed by 16 zeros:
//       D  -  1  2  3  4  5  6  7  8  9  T  J  Q  K  A
o = [ 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ];

For each card rank in the hand, the corresponding slot in o[] is incremented. Once joined back to a string, we can apply the following regular expressions to detect each type of hand:
 hand        | pattern     | full regex              | example
-------------+-------------+-------------------------+-------------------
 single      | 1           | /9(0*)(1)0*$/           | 90000100000000000
 pair        | 2           | /9(0*)(2)0*$/           | 90000002000000000
 3-of-a-kind | 3           | /9(0*)(3)0*$/           | 90003000000000000
 full house  | (20*)3|30*2 | /9(0*)((20*)3|30*2)0*$/ | 90020000030000000
 straight 5+ | 1{5,}       | /9(0*)(1{5,})0*$/       | 90000111110000000
 tractor     | 22+         | /9(0*)(22+)0*$/         | 90000000000022200
 bomb        | 4           | /9(0*)(4)0*$/           | 90000000000000004

If the hand does not trigger any of these regular expressions, it's invalid.
The value of the hand is given by the number of zeros just after the leading \$9\$ (the higher, the better). A special case is a full house where the rank of the triple is higher than that of the pair, in which case we need to add the length of the (20*) pattern.
The phoenix (i.e. the wildcard) is simply replaced with each possible card rank, starting with the highest one, until a match is detected.