[Question]
  [
In sporting competitions, it often happens that winners are presented on podiums, with the first-place person on the highest in the middle, the second-place person on the middle height to the left, and the third-place person on the lowest and to the right. We're going to recreate that here with some special tweaks.
The podiums are presented below:
```
     @---@
     | @ |
@---@| | |
| @ || | |
| | || | |@---@
| | || | || @ |
```
This will form the basis for this challenge. The next step is to make the podiums wide enough to fit the people (printable ASCII strings) that are on them. However, we want to ensure aesthetic beauty (because this is a fantastic photo opportunity), so each podium needs to be the same width, and the width must be odd. Additionally, the people will (obviously) want to stand in the center of the podium, so the strings must be centered as best as possible. (You can align to either the left or the right, and it doesn't need to be consistent.) The above podiums are the minimum size, and are considered `3` wide.
For example, given the input `["Tom", "Ann", "Sue"]` representing first-, second-, and third-place respectively, output the following podiums:
```
      Tom
     @---@
 Ann | @ |
@---@| | |
| @ || | | Sue
| | || | |@---@
| | || | || @ |
```
However, if we have `Anne` instead of `Ann`, we'll need to go up to the next size, `5`, and center the strings as best as possible. Here, I'm aligning so the "extra" letter of `Anne` is to the left of center, but you can choose which side to align to.
```
         Tom
       @-----@
 Anne  |  @  |
@-----@|  |  |
|  @  ||  |  |  Sue
|  |  ||  |  |@-----@
|  |  ||  |  ||  @  |
```
Let's go for some longer names. How about `["William", "Brad", "Eugene"]`:
```
          William
         @-------@
  Brad   |   @   |
@-------@|   |   |
|   @   ||   |   | Eugene
|   |   ||   |   |@-------@
|   |   ||   |   ||   @   |
```
Here we can see that `Brad` has a lot of whitespace, `Eugene` less so, and `William` fits just right.
For a longer test case, how about `["A", "BC", "DEFGHIJKLMNOPQRSTUVWXYZ"]`:
```
                                     A
                         @-----------------------@
           BC            |           @           |
@-----------------------@|           |           |
|           @           ||           |           | DEFGHIJKLMNOPQRSTUVWXYZ
|           |           ||           |           |@-----------------------@
|           |           ||           |           ||           @           |
```
Finally, we have the smallest possible input, something like `["A", "B", "C"]`:
```
       A
     @---@
  B  | @ |
@---@| | |
| @ || | |  C
| | || | |@---@
| | || | || @ |
```
---
* Input and output can be given by [any convenient method](http://meta.codegolf.stackexchange.com/q/2447/42963).
* The input is guaranteed non-empty (i.e., you'll never receive `""` as a name).
* You can print it to STDOUT or return it as a function result.
* Either a full program or a function are acceptable.
* Any amount of extraneous whitespace is acceptable, so long as the characters line up appropriately.
* [Standard loopholes](http://meta.codegolf.stackexchange.com/q/1061/42963) are forbidden.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so all usual golfing rules apply, and the shortest code (in bytes) wins.
  
[Answer]
# JavaScript (ES8), 196 bytes
```
a=>`141
101
521
031
236
330
332`.replace(/./g,n=>[...`@-@   |@||||`.substr(n*3,3)].join(' -'[+!+n].repeat(m/2))||a[n-=4].padStart(m+l[n]+3>>1).padEnd(m+3),m=Math.max(2,...l=a.map(s=>s.length))&~1)
```
[Try it online!](https://tio.run/##jU3bUoMwEH3nKyIPNhFIG1J9C9OL1Xqpt1arIjPEklI6ITBAHR8Yfx1Dn9VxZ86e2bPn7G75By9XRZJXjsoi0axZw5kXkj4xSI8Yxy4xepQYLj0xKO1puCEuRC75SsAu7sa2Yp6PMQ4HzgAAUA9qXSEud@9lVUB1RG2KArzNEgU7wOn41oGlgvaC4BVMuy5Cdc195bB@gHMezSteaN2Svgos6nkEtepERVqjyE7ZjFcbnPJP6Nr6q2RcDzksmVdiKVRcbRA6/CKoWWWqzKTAMovhGvrmIktNG5hDpVqa74QZIGAB802ZyPjdLP7hXiZSJnyfGBU8anmyi4X6MzTc28dtP52cnU8vLq@uZze3d/cP88Xj0/L55VWnf4yZI41xu22@AQ "JavaScript (Node.js) – Try It Online")
[Answer]
# [Groovy](http://groovy-lang.org/), ~~187~~, ~~176~~, ~~156~~, 150 bytes
```
f={n->m=n*.size().max()|1;h=' '*(m/2);'30734715746756276647665'*.toLong().sum{(n*.center(m+2)+[' '*(m+2),"@${'-'*m}@","|$h@$h|","|$h|$h|",'\n'])[it]}}
```
[Try it online!](https://tio.run/##fYxLT4NAFIX3/AoyIbkzlKKlwCwaDFXrq76pVsUuiE4LCTMYCqYK/HYcWheuXNxzT3K@c1Z5ln1@te3Sq0T/gHtCN9fJN8PE5NEGk3owij1QQcd8zyIjGO7ToU0HDrVd6rgWdV1bngO6WWRBnOWFLK5LXmG588ZEwXLMexbphbsNaQ3kaxX0QeeNjwxUa7GvxfXO1VsHrwIWJEyKRdO0H3kiilTgJQ5hlnEwYCyE1KBkEiLKb64ipCh/2XmSpkkkeRUO8@i9@5NyxcT/rfGWP@r0eHJyenZ@Mb28ur65vbsPZg@P86fnl67e/gA "Groovy – Try It Online")
(note: the tio groovy interpreter could not handle indexing Lists using Long values even though groovy 2.5.6 can. Thus the tio answer is using `*.toShort()` instead of `*.toLong()` which adds a byte)
Defines a closure `f` which can be called via: 
```
println(f(['tom','ann','sue']))
```
where `f` returns a string.
### Explanation:
Unobfuscating the code, we have: 
```
f={n->
  m=n*.size().max()|1
  h=' '*(m/2)
  a=n*.center(m+2)+[' '*(m+2),"@${'-'*m}@","|$h@$h|","|$h|$h|",'\n']
  '30734715746756276647665'*.toLong().sum{a[it]}
}
```
* `f={n->` - define closure f with one in-param `n`
* `m=n*.size().max()|1` - find max name len, binary-or to odd number
* `h=' '*(m/2)` - h will contain floor(m/2) spaces, used later
* `a=...`- creates an encoding list with elements:
	+ indexes 0,1,2 - names, centered to max len
	+ index 3 - m+2 spaces
	+ index 4 - `@---@` pattern, padded to len
	+ index 5 - `| @ |` pattern, padded to len
	+ index 6 - `| | |` pattern, padded to len
	+ index 7 - newline
* `'307...'*.toLong().sum{a[it]}`- use indicies into the encoding list to build the result. `.sum` uses the fact that string + string in groovy is valid.
* note that the expression `'3073...'*.toLong()` uses the `*.` spread operator to call `toLong()` on each character, returning a list of numbers.
* note in the answer the variable `a` has been inlined,nelines removed etc.
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 45 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
ｒ３５１⁰｛|＊@；∔；Ｊ└ｌ２Ｍ２％±├ ××ｌ⇵╷-×└＋-α∔ｋ＋│∔⇵；｝┐＋＋⇵
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JXVGRjUyJXVGRjEzJXVGRjE1JXVGRjExJXUyMDcwJXVGRjVCJTdDJXVGRjBBQCV1RkYxQiV1MjIxNCV1RkYxQiV1RkYyQSV1MjUxNCV1RkY0QyV1RkYxMiV1RkYyRCV1RkYxMiV1RkYwNSVCMSV1MjUxQyUyMCVENyVENyV1RkY0QyV1MjFGNSV1MjU3Ny0lRDcldTI1MTQldUZGMEItJXUwM0IxJXUyMjE0JXVGRjRCJXVGRjBCJXUyNTAyJXUyMjE0JXUyMUY1JXVGRjFCJXVGRjVEJXUyNTEwJXVGRjBCJXVGRjBCJXUyMUY1,i=JTVCJTIyQUFBQUFBJTIyJTJDJTIwJTIyQiUyMiUyQyUyMCUyMkNEJTIyJTVE,v=8)
Explanation:
```
r    Center the input, preferring left. Converts to an ASCII-art object
     which pads everything with spaces. This is the bulk of the magic.
 251⁰{ .... }            for each number in [2, 5, 1]:
      |*                 repeat "|" vertically that many times
        @;∔              prepend an "@" - a vertical bar for later
           ;             swap top 2 stack items - put the centered art on top
            J            push the 1st line of it (removing it from the art)
             └           order the stack to [remaining, "@¶|¶|..", currentLine]
              l          get the length of the current line
               2M        max of that and 2
                 2%      that % 2
                   ±├    (-that) + 2
                      ×× prepend (-max(len,2)%2) + 2 spaces
l                 get the length of the new string
 ⇵╷               ceil(len / 2) -1
   -×             repeat "-" that many times - half of the podiums top
     └            order stack to [art, currLine, "@¶|¶|..", "----"]
      +           append the dashes to the vertical bar = "@-----¶|¶|.."
       -α∔        vertically add "-" and the original vertical bar - "-¶@¶|¶|.."
          k       remove the last line of that to make up for the middles shortness
           +      and append that horizontally - half of the podium without the name
            │     palindromize the podium
             ∔    and prepend the name
              ⇵   reverse vertically so the outputs could be aligned to the bottom
               ;  and get the rest of the centered input on top
Finally, 
┐     remove the useless now-empty input
 ++   join the 3 podium parts together
   ⇵  and undo the reversing
```
Abuses "and it doesn't need to be consistent", making it pretty unintelligible.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~197~~ 190 bytes
```
n=input()
w=max([3]+map(len,n))
w+=~w%2;W=w+2
S=('{:^%d}'%w).format
x,y,s='@| '
a,b,c=map(S,n);A,B,C=x+'-'*w+x,y+S(x)+y,y+S(y)+y
for l in-~W*s+a,s*W+A,s+b+s+B,A+C,B+C+s+c,C+C+A,C+C+B:print l
```
[Try it online!](https://tio.run/##TU9NT4NAFLzvr9hsQvh4rx4wXtpsImzrt1alitrUZNuiksCWAA0QtX8dF7xwmZnMvDfJZE35tVNuK@bTGc8ZY63iscr2pWWTiqeytpbHK0hlZiWRQmVrF/ihMtxJyCtwScAt83v8bmx/TaOyjz52eSpLUmODBTdPf6hJJK5xw7uGQP9PPPRR8BrMkelUoA8hsGobml40WhDdQRMaq9EhdAqQWDgheFjAGgrw0QOBPgitNyg0ez364yyPVUmTVk8gJKqjDe0mOSftki12KUPKPKU6CvYRW5GhGw3tME6SWPaRn8ttx7P9Z6T@U6/3RYfT2dn5xeXV9c3t3fz@4TFYPD2HL69vg7MOBFv9AQ "Python 2 – Try It Online")
-6 bytes, thanks to Andrew Dunai
[Answer]
# [Python 2](https://docs.python.org/2/), 157 bytes
```
a=input()
i=7
while i:print''.join(([a[k/2]]+list('-@||||    '))[7-i-k].center(max(map(len,a))|1,'- '[i+k!=6]).join('@ |'[cmp(i+k,6)]*2)for k in(2,0,4));i-=1
```
[Try it online!](https://tio.run/##JYzRCoIwGIXve4rlzfbnZimhUAzsGepu7EJk4d90DptU4Lvbog8OB74Dx39CN7piXRuJzs@BwQZltXl12BuCJz@hC5RmjxEdY6pRdl9onfb4DIyKeomQCAVQlUBhddYaF8zEhuYd41lvHG8AlpxTQajC1G5lqeF/SGuyUNUOnkXPS9C7Au7jRCyJY8EP/AhwRiHzdVXJbRwSTpKLc@bX19kk@gs "Python 2 – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 63 bytes
```
≔÷⌈ＥθＬι²ηＦ³«Ｊ×ι⁺³⊗η⊗﹪⁻¹ι³⟦◧§θι⁺⊕η⊘⊕Ｌ§θι⟧≔⁻⁷ⅉιＰ↓ι@ηＰ↓ιＰ↓@@¹ηＰ↓ι@
```
[Try it online!](https://tio.run/##jU9PS8MwFD@vnyL09ArxMHsQ3GWTClZW6GEgMnqITdY@SJPaJnUgfvaadBUrghgIL@@937@UNetKzeQ47voeKwWpMgkOyAVk7IyNbVxt4ZWSvVCVqQGjKKLk2t062gQn3RGII/IerB5t0x40HLARPSAlubQ9xJQk2r5IwaGeiF9dprmVGjJUDrWmBN0udohNsMo7VAaOOeN7cTKwM6ni4uwjeNAkm6qyE41QZtKl5IHJwT2X4znuD/Z0Cu8xf/Zif0PJM/hw6FeZlQbbKcNtot/UPL6kCrfhd1P/Af89DrdL7vp/MkvXj3E8HsMnlBJZEzrBu45xX@9tJZQIi2K8GuQn "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
≔÷⌈ＥθＬι²η
```
Calculate the number of spaces in each half of a podium.
```
Ｆ³«
```
Loop over each place. Note that input is expected to be in the order 2nd, 1st, 3rd.
```
Ｊ×ι⁺³⊗η⊗﹪⁻¹ι³
```
Position to the start of the line that will have the text.
```
⟦◧§θι⁺⊕η⊘⊕Ｌ§θι⟧
```
Output the text with enough left padding to centre it.
```
≔⁻⁷ⅉι
```
Get the height of the podium.
```
Ｐ↓ι@ηＰ↓ιＰ↓@@¹ηＰ↓ι@
```
Draw the podium.
Alternative approach, also 63 bytes:
```
≔÷⌈ＥθＬι²ηＦ³«Ｊ×ι⁺³⊗η⊗﹪⁻¹ι³⟦◧§θι⁺⊕η⊘⊕Ｌ§θι⪫@-@×-η⟧Ｅ⁻⁷ⅉ⪫⪫||§|@¬κ× η
```
[Try it online!](https://tio.run/##VY8/a8MwEMXn@FMITWeQh9ZDhyxJSaEOcfEQKMVkUCzFPipLqS2bQN3P7kp20j8CcdLpvZ/eFRVvCsPVOK7bFksNibYb7FFISPkF66529QwfjOykLm0FGIYhI/duV@EyOJmGQBySz2Cx7erz3sAea9kCMpKproWYkY3pjkoKqCbj7ZYa0SkDKWqnumME3VvsFMtgkTWoLeQZFzt5srC2iRby4iN40YRNdNHIWmo7cRl55qp3x7/ta9x/7mkxsjWoga6iFWVkjksj6ucJD7//@6nndA@MvMGPbzYPgzPc2HTwpBdj4X3iX5lkZvqZvsYxz@krKoW8dm362HDh61NXSi3p4TBGvfoG "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
≔÷⌈ＥθＬι²η
```
Calculate the number of spaces in each half of a podium.
```
Ｆ³«
```
Loop over each place. Note that input is expected to be in the order 2nd, 1st, 3rd.
```
Ｊ×ι⁺³⊗η⊗﹪⁻¹ι³
```
Position to the start of the line that will have the text.
```
⟦◧§θι⁺⊕η⊘⊕Ｌ§θι
```
Output the text with enough left padding to centre it.
```
⪫@-@×-η⟧
```
Also output the top of the podium by inserting `-`s between the characters of the string `@-@` to reach the correct width.
```
Ｅ⁻⁷ⅉ⪫⪫||§|@¬κ× η
```
Print the remainder of the podium by spacing the `|`s appropriately, except that the middle character is a `@` on the first row.
[Answer]
# R 308 302 299
-6 bytes thanks to @JAD  
-3 bytes thanks to @Guiseppe, now I'm under 300
```
function(a){i=max(1,nchar(a)%/%2)
e=2*i+1
`~`=rep
g=' '
s=g~e+2
b='@'
p='|'
t=c(b,'-'~e,b)
x=c(p,g~i,b,g~i,p)
h=sub(b,p,x)
a=lapply(a,function(q){r=nchar(q);l=(e-r)/2+1;if(r%%2<1)c(g~l,q,g~l+1)else c(g~l,q,g~l)})
cat(s,a[[1]],s,s,t,s,a[[2]],x,s,t,h,s,x,h,a[[3]],h,h,t,h,h,x,fill=length(t)*3,sep='')}
```
There's probably a better way to create the layout; I should try what options I have for data frames.
[Try it online](https://tio.run/##fVBba8IwFH7Pr@hLSWIj0vqogU3n7nfdVQTTLr1ArDFNocPZv@6OHewCMk7ywXfhnJOYrVbCxkuzKJx@29nGZR7ZbJkTQdcZX4iK@CyPUmFAcDtuQJHkQSvzfDSv59xIjRKOHYwKntTSC1DI8QFGmuMPjCyPSMhwG9eShRRVQDVL6oyFDWqKUl6UIWQ0qygSXAmt1TsR7HuLFV0b/jV/RXuKE9k2tBN4fi@LiXHdoO/TiCS1YivoqTyfSlVI55dENxRFwpKCienUn81YAWVZQwOgVUNTwAoQxC6IKZRtsGJxphRXMk9sSixtdVkh4XmYbn5@jkQEY9YcStEf@TDPQZ4sF4DjUu7z5b@BgRFvYD3BFpnYhUZlIvM9jcAaDAGORscnp2fnF5dX1ze3d/fjycPj88vr/jzc4c7ZfgI)
[Answer]
# [Clean](https://github.com/Ourous/curated-clean-linux), 209 bytes
```
import StdEnv,Data.List
k=[' @|||||']
$l#m=max(maxList(map length l))3/2*2+1
=flatlines(transpose[(spaces(n*2)++g)%(0,6)\\n<-[1,0,2],g<-[k:[[c,'-':tl if(i==m/2)k['  '..]]\\c<-cjustify m(l!!n)&i<-[0..]]]++[k]])
```
[Try it online!](https://tio.run/##JU@xasMwFNz9FQpNKymWHceFDiGGUpKhkKGQoYOsQZVlV7UkG0suDfTbq8rkwePdvePgTmjJbTBDM2sJDFc2KDMOkwcX35zsNzlyz/Ozcj7pKwrB8@8ykCVrfWcqw39Q3EWOdwRa2s5/Ao3x47bclOkuqVrNvVZWOuQnbt04OEmRG7mIH7spcZp2@B4V5AnXtT1kdEcKUjLSRdjvKRUEZnDvNVAtUlVltiXuYwwA85yxuhaHTHzNzqv2CgzSq5XFDypai0VmaUp7xnC4eB4LVWANKIXvSmvFDWQEUPgy8eaGTnMnrYSMhT8RM3cuZK/ncLxabpS4kbdYpR0mE7KPfw "Clean – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 188 bytes
```
a,b,c=l=input()
s=max(map(len,l))/2or 1
A='@'+'--'*s+'-@'
D=(' '*s).join
C=D('|@|')
D=D('|||')
d=str.center
S=s*2+3
for l in' '*S+d(a,S),' '*S+A,d(b,S)+C,A+D,C+D+d(c,S),D+D+A,D+D+C:print l
```
[Try it online!](https://tio.run/##JYxNDsIgEIX3nILdQJnWWHcmJEW4QU9Af4w1lDYUE0169wq6ee99@TKzfuJj8fVxWOywl05Ofn1FxskmZ/tms12ZGz06zk/1EuiZKAkNCChLKLZUDRAjGdBEvHoukydaGgZ7swNPJs89z0FuMVT96OMYSCu3ohYXck8fHZ18Pm/FwCy2HP@gcGBdQqFRCYNamOT77E2a6pf6uobJR@qOg4ECpHCzObXtgH8B "Python 2 – Try It Online")
-5 thanks to [TFeld](https://codegolf.stackexchange.com/users/38592/tfeld).
[Answer]
# PHP, 147 bytes
golfed 93 bytes off my initial idea, a straight forward `<?=`:
```
for(;~$v=_616606256046543440445[++$i];)echo$b="@   || "[$v],str_pad(($v&4?"|@":$argv)[$v&3],max(array_map(strlen,$argv))," -"[!$v],2),$b,"
"[$i%3];
```
takes names from command line arguments. Run with `-nr` or [try it online](http://sandbox.onlinephpfunctions.com/code/5b1c14f47645d5669540cd7c0f9c32ae86cb147b).  
Requires PHP 7; yields warnings in PHP 7.2 (and later, presumably). See the TiO for a +5 byte fix.
## mapping:
```
0:@---@     = top border
1,2,3       = $argv with spaces
4: "| | |"  = default
5: "| @ |"  = below top
6: "     "  = empty
```
## breakdown:
```
for(;~$v=_616606256046543440445[++$i];)echo # loop through map:
    $b="@   || "[$v],                       # print left border
    str_pad(                                # print padded string:
        ($v&4?"|@":$argv)[$v&3],                # string to be padded
        max(array_map(strlen,$argv)),           # pad length = max argument length
        " -"[!$v],                              # pad with: dashes if top border, spaces else
        2                                       # option: center text (pad on both sides)
    ),
    $b,                                     # print right border
    "\n"[$i%3]                              # add linebreak every three items
;
```
The pre-increment for `$i` saves me from any tricks for the newlines.  
The blank for `6` can also be empty; so I did that.  
But using `$argv[0]` for the top border string `-` was the nicest golf ever. (and saved 9 bytes!)
[Answer]
# Go, 436 bytes
Go is terrible for golf. But:
```
package main;import ("fmt";"os");func main(){;z:=os.Args;f:=3;for i:=1;i<4;i++{;if len(z[i])>f{;f=len(z[i]);};};f+=1-f%2;p:=(f-1)/2+1;b:="@";for j:=0;j<f;j++{;b+="-";};b+="@";x:=fmt.Sprintf("|%*v%*v",p,"@",p,"|");y:=fmt.Sprintf("|%*v%[1]*v",p,"|");fmt.Printf("%*v%*v\n%*v%v\n%*v%*v\n%v%v\n%v%v%*v\n%v%v%v\n%v%v%v",f+2,"",p+1+len(z[1])/2,z[1],f+2,"",b,p+1+len(z[2])/2,z[2],2*f+3-p-len(z[2])/2,x,b,y,x,y,p+1+len(z[3])/2,z[3],y,y,b,y,y,x)}
```
Broken down:
```
package main
import (
  "fmt"
  "os"
)
func main() {
  z:=os.Args
  f:=3
  for i:=1;i<4;i++{
    if len(z[i])>f{
      f=len(z[i])
    }
  }
  f+=1-f%2
  p:=(f-1)/2+1
  b:="@"
  for j:=0;j<f;j++{
    b+="-"
  }
  b+="@"
  x:=fmt.Sprintf("|%*v%*v",p,"@",p,"|")
  y:=fmt.Sprintf("|%*v%[1]*v",p,"|")
  fmt.Printf("%*v%*v\n%*v%v\n%*v%*v\n%v%v\n%v%v%*v\n%v%v%v\n%v%v%v",
  f+2,"",p+1+len(z[1])/2,z[1],
  f+2,"",b,
  p+1+len(z[2])/2,z[2],2*f+3-p-len(z[2])/2,x,
  b,y,
  x,y,p+1+len(z[3])/2,z[3],
  y,y,b,y,y,x)
}
```
[Answer]
# Java 8, ~~399~~ ~~394~~ 373 Bytes
This solution is probably way too long, but it is a solution :)
```
static String r(String[]p){String s="";int l[]=new int[]{p[0].length(),p[1].length(),p[2].length()},m=Math.max(l[0],Math.max(l[1],l[2]))+2,i,q,j,a,k,t;if(m%2==0)m++;if(m==3)m=5;for(i=0;i<7;i++){for(q=0;q<3;q++)for(j=0;j<m;j++){a=(2*q+1)%3;k=2*a;t=(m-l[a])/2;s+=i==k?j>=t&j<t+l[a]?p[a].charAt(j-t):" ":i==k+1?j%(m-1)==0?"@":"-":i>=k+2?j%(m-1)==0?"|":j==m/2?i==k+2?"@":"|":" ":" ";}s+="\n";}return s;}
```
Saved 5 Bytes by directly iterating in order (a=1,0,2 instead of q=0,1,2; a=f(q))
```
static String r(String[]p){String s="";int l[]=new int[]{p[0].length(),p[1].length(),p[2].length()},m=Math.max(l[0],Math.max(l[1],l[2]))+2,i,j,a,k,t;if(m%2==0)m++;if(m==3)m=5;for(i=0;i<7;i++){for(a=1;a<4;a=a==1?0:a+2)for(j=0;j<m;j++){k=2*a;t=(m-l[a])/2;s+=i==k?j>=t&j<t+l[a]?p[a].charAt(j-t):" ":i==k+1?j%(m-1)==0?"@":"-":i>=k+2?j%(m-1)==0?"|":j==m/2?i==k+2?"@":"|":" ":" ";}s+="\n";}return s;}
```
Saved 21 Bytes thanks to @KevinCruijssen:
```
static String r(String[]p){String s="";int l[]=new int[3],m=0,i,j,a,k,t;for(String x:p)l[m++]=x.length();m=Math.max(l[0],Math.max(l[1],l[2]))+2;m+=m%2<1?1:m==3?2:0;for(i=0;i<7;i++,s+="\n")for(a=1;a<4;a=a==1?0:a+2)for(j=0,k=2*a,t=(m-l[a])/2;j<m;j++)s+=i==k?j>=t&j<t+l[a]?p[a].charAt(j-t):" ":i==k+1?j%~-m<1?"@":"-":i>=k+2?j%~-m<1?"|":j==m/2?i==k+2?"@":"|":" ":" ";return s;}
```
As @KevinCruijssen suggested, one could also use `var` instead of `String` in Java 10+ and save some extra Bytes. I don't do this for the simple reason that I don't have Java 10 yet :D also, lambdas could be used. But this would only reduce the amount of bytes if we would leave out assigning it to a `Function<String[],String>` variable.
In expanded form:
```
static String r(String[]p){
    String s=""; //The string that will be returned
    int l[]=new int[3], //An array containing the lengths of our three names
            m=0, //tmp variable for filling l
            i,j,a,k,t; //some declarations to save a few bytes lateron
    for(String x:p) l[m++]=x.length();
    m=Math.max(l[0],Math.max(l[1],l[2]))+2;
    m+=m%2<1? //ensure odd length of the podests
        1
        :m==3?2:0; //ensure the length is at least 3 (in my code, m is the length of the podests + 2)
    for(i=0;i<7;i++,s+="\n") //iterate by row
        for(a=1;a<4;a=a==1?0:a+2) //iterate by place: a=1,0,2
            for(j=0,k=2*a,t=(m-l[a])/2;j<m;j++) //iterate by column
                //k is the row number from top in which the a-th name goes
                //t is the column at which the name starts
                //now, append the right char:
                s+=i==k? //write the name
                    j>=t&j<t+l[a]?
                        p[a].charAt(j-t)
                        :" "
                    :i==k+1? //write the top of the podest ("@---@")
                        j%~-m<1?
                            "@"
                            :"-"
                    :i>=k+2? //write the bottom of the podest ("|  |@  |")
                        j%~-m<1? //the left and right edge of the podest
                            "|"
                            :j==m/2? //the center of the podest
                                i==k+2? //are we at the first row of the bottom?
                                    "@" //the case where we have to write "| @ |"
                                    :"|" //the case "| | |"
                                :" "
                        :" "
                ;
    return s;
}
```
The input has to be given as `String`-array of length 3. An example looks like this:
```
public static void main(String[] args){
    System.out.print(r(new String[]{"Anthony", "Bertram", "Carlos"}));
}
```
Output:
```
          Anthony          
         @-------@         
 Bertram |   @   |         
@-------@|   |   |         
|   @   ||   |   | Carlos  
|   |   ||   |   |@-------@
|   |   ||   |   ||   @   |
```
[Answer]
# C(GCC) ~~302~~ ~~293~~ ~~292~~ ~~289~~ 287 bytes
-6 byte thanks to ceilingcat
```
#define P(h,n)r=w+2-L[n];i/h?printf("%*s%*s%*s",-~r/2,D,L[n],i>h?D:N[n],r/2,D):printf(~i/h?"@%s@":"|%*s%c%*s|",~i/h?D+1:w/2,D,i>h-3?64:'|',w/2,D);
f(int**N){char L[3],w=3,i=3,r,D[99]={};for(;i--;)w=w<(L[i]=strlen(N[i]))?L[i]|1:w;memset(D+1,45,w);for(i=7;i--;puts(D)){P(4,1)P(6,0)P(2,2)}}
```
[Run it here](https://tio.run/##LU/BboMwDL33K6JMVWNq1JV2nUqW0UkcK1RpuyEOFQsj0kirQMUB6K@zhE5ybOvZ7/kl93/yfByfvmWhtCQnVqIGI9pl4B9TnXG1KqOrUbopGJ179SMo@nezCjBGt4PqvYziMHHthEL4z7g7Nj3M6wMNae@4uU09xWkQL9dhO6lYAX8T7bbhol/gBAGfFcxqeF4CXV6eDTmmmwxbsUFln8E43e8z0Q28uBjGle9zaEX7xo6pykTdmF@pWWJ7gMhBvT3FK1nVsmH2Lm5fsIWJq8TrRL/emprFAN2JbXENJ7bDZ5sDDGAYRmuFVGelGcy6GSHOkUcSa4kI0tGvS0WR0A@tpaufN0kHwu1ewRL7k2H8Aw)
Ungolfed and explained (technically you can't have comments after back slashes in macros, so this won't run)
```
#define P(h,n)\
    r=w+2-L[n];\ //get leftover width
    i/h?\ //if i >= h
        printf("%*s%*s%*s",-~r/2,D,L[n],i>h?D:N[n],r/2,D):\//if too high print all spaces, otherwise center the name
        printf(~i/h?"@%s@":"|%*s%c%*s|",~i/h?D+1:w/2,D,i>h-3?64:'|',w/2,D);
//if (i == h - 1) print top row using D calculated if row right below top, else print '@'(64) in center, otherwise '|'
f(int**N){
    char
        L[3],//lengths of each string
        w=3,//width (init to minimum)
        i=3,//index, used in for loops
        l,//left padding
        r,//right padding
        D[99]={};//string of '-' of correct length (max 99) but first char is null for empty string
    for(;i--;)//i was set to 3 before, i will be {2,1,0}
        w=w<(L[i]=strlen(N[i]))?//set length to str len and compare to longest width so far
            L[i]|1://set it to length if longer, but make sure it is odd
            w;//do not replace
    memset(D+1,45,w); //set the first w bits of D to '-', leaves a null terminator
    for(i=7;i--;puts(D)){//i will be {6...0}
        P(4,1)//print second place, 4 high
        P(6,0)//print first place, 6 high
        P(2,2)//print thrid place, 2 high
    }
}
```
Here is the calling code
```
int main()
{
  char* N[3] = {"Tom", "Anne", "Sue"} ;
  f(N);
}
```
and output
```
         Tom         
       @-----@       
  Anne |  @  |       
@-----@|  |  |       
|  @  ||  |  |  Sue  
|  |  ||  |  |@-----@
|  |  ||  |  ||  @  |
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell) for Windows, ~~231~~ 223 bytes
```
param($a)$w=($a|% le*|sort)[-1]
if(3-gt$w){$w=3}$w+=1-$w%2
0..6|%{$r=$_
-join($a|%{$m=' -'[5-eq($o=$r+2*(++$i%3))]
$e='     @|||||'[$o]
$x=(,''*4+$_,'','@'+,'|'*4)[$o]
"$e$($x|% *ft(($x.Length+$w)/2-.1)$m|% *ht $w $m)$e"})}
```
[Try it online!](https://tio.run/##nVVrj5pAFP3Or7gh1w4I2Kptv5Ggdtttu33uttvWbDakOz4aHhYxmDj@dnsZUJGFXeskCJ5z7uGeYTIzCxMezSfc8zY4AhtWm5kbub6Gro6JTTfRAI83xTyMYn1otW@U6UjrWuMYE31Fiu4aE8NuW5g0OsqzVuulaKwwsvFWsf6E00AarNC3GVhs@MLifzUMbYyMTlMzDJw2urp@oyAnPh2OSAcbYkjg0tZMxprPDbylu8kcZphMEKBLXkWOGi6pv@Yo1uipdcGDcTwxqLOnHavV1tFPyUkMmAD6OnJ1ra83a0VxNEUxNUW@UWO9ICD3q9Cn38sFZ7opmawjIDx7YEXYsSzLOYTJBgQ4dBVhKRQgSrAUZjC9sgCLHJZ192FZxxS91D9/IEAxQzlGFmQb5TAMh7RnB/LODyPJUCDuk3nJjkzTFUmxJ3OfajL3KUXtR@4dhbyeet7UTeOeLcY8qEgMuQTqcm@T77MXJel7IAvnwD5keQ6yWQBRKdkV7yVZt4cScSDZ@dZLdr7luRnQfPToenX2@s3523fvLz58/PT5y9fLq2/fr3/8/FUxSQ@M3lEq9pjlNk95OP9j2R8UBaJoX4NXW9Y2I2psHresbabesubzVFqKoyxrc51uWZurvOjyNTcor64eHLdrQh9O2jVhAKfsmjr9bcBKCjBwfT43kS9n/HfM7@j0o2NLMhGfL7yYgCd0KGY6Sag5o9JBpu4K1WKRst78Aw "PowerShell – Try It Online")
Input is array `@('second','first','third')`. Unrolled version:
```
param($arr)
$width=($arr|% length|sort)[-1]
if(3-gt$width){$width=3}
$width+=1-$width%2
0..6|%{ $row=$_                         # 7 rows
    -join($arr|%{                       # 3 joined columns. Each column array contains 11 lines.
        $offset = $row+2*(++$i%3)       # (2,4,0) -> offset in column array #   0:
        $middle = ' -'[5-eq$offset]                                         #   1:
        $edge   = '     @|||||'[$offset]                                    #   2:
        $center = ('','','','',$_,'','@','|','|','|','|')[$offset]          #   3:
                                                                            #   4:  name
        # pad $x to a center                                                #   5: @---@
        $center = $center|% PadLeft (($center.Length+$width)/2-.1) $middle  #   6: | @ |
        $center = $center|% PadRight $width $middle                         #   7: | | |
                                                                            #   8: | | |
        # add the $edge                                                     #   9: | | |
        "$edge$center$edge"                                                 #  10: | | |
    })
}
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 43 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
¿⌐cF◄àë+±√¼∙]╔5B\d☺↨m█ewτ─º╞═ó○♣zG-█K↨ÄV┐§x
```
[Run and debug it](https://staxlang.xyz/#p=a8a963461185892bf1fbacf95dc935425c6401176ddb6577e7c4a7c6cda209057a472ddb4b178e56bf1578&i=[%22Tom%22,+%22Anne%22,+%22Sue%22]%0A[%22William%22,+%22Brad%22,+%22Eugene%22]%0A[%22A%22,+%22BC%22,+%22DEFGHIJKLMNOPQRSTUVWXYZ%22]%0A[%22A%22,+%22B%22,+%22C%22]&a=1&m=2)
]