import Icon from './Icon';
 
 const ToggleSwitch = ({
+       id = null,
        isInvalid = false,
        isValid = false,
        name = '',
        if (isValid) classNames.push('is-valid');
        if (readonly) classNames.push('readonly');
 
-       return <div
-                       className={classNames.join(' ')}
-                       role="button"
-                       aria-pressed={value}
-                       tabIndex="0"
-                       title={title}
-                       onBlur={onBlur ? () => onBlur({ target: { name, value } }) : null}
-                       onClick={handleClick}
-                       onKeyDown={handleKey}
-               >
-                       <div className="handle">
-                               <span className="handle-label">
-                                       {value
-                                               ? onLabel || <Icon name="check" />
-                                               : offLabel || <Icon name="times" />
-                                       }
-                               </span>
-                       </div>
-               </div>;
+       return <button
+               aria-checked={value ? 'true' : 'false'}
+               className={classNames.join(' ')}
+               id={id}
+               role="switch"
+               onBlur={onBlur ? () => onBlur({ target: { name, value } }) : null}
+               onClick={handleClick}
+               onKeyDown={handleKey}
+               tabIndex="0"
+               title={title}
+               type="button"
+       >
+               <div className="handle">
+                       <span className="handle-label">
+                               {value
+                                       ? onLabel || <Icon name="check" />
+                                       : offLabel || <Icon name="times" />
+                               }
+                       </span>
+               </div>
+       </button>;
 };
 
 ToggleSwitch.propTypes = {
+       id: PropTypes.string,
        isInvalid: PropTypes.bool,
        isValid: PropTypes.bool,
        name: PropTypes.string,
 
 import ToggleSwitch from '../common/ToggleSwitch';
 import laravelErrorsToFormik from '../../helpers/laravelErrorsToFormik';
 import { withUser } from '../../hooks/user';
+import yup from '../../schema/yup';
 
 const channelCompare = (a, b) => a.channel.title.localeCompare(b.channel.title);
 
                        ? user.channel_crews[0].channel_id : 0,
                episode_id: episode ? episode.id : 0,
        }),
+       validationSchema: yup.object().shape({
+               accept_comms: yup.bool(),
+               accept_tracker: yup.bool(),
+               channel_id: yup.number(),
+               episode_id: yup.number(),
+       }),
 })(RestreamAddForm));
 
 
        const onHideEpisodeDialog = React.useCallback(() => {
                setShowEpisodeDialog(false);
-               setEditEpisode(null);
        }, []);
 
        const onAddRestream = React.useCallback(episode => {
+               setRestreamChannel(null);
                setRestreamEpisode(episode);
                setShowRestreamDialog(true);
        }, []);
                                } : episode
                        ));
                        toastr.success(t('episodes.restreamDialog.addSuccess'));
+                       const channel = newEpisode.channels?.find(c => c.id === values.channel_id);
+                       if (channel) {
+                               setRestreamEpisode(episode => ({
+                                       ...episode,
+                                       ...newEpisode,
+                               }));
+                               setRestreamChannel(channel);
+                       } else {
+                               setShowRestreamDialog(false);
+                       }
                } catch (e) {
                        toastr.error(t('episodes.restreamDialog.addError'));
                        throw e;
                }
-               setRestreamEpisode(null);
-               setShowRestreamDialog(false);
        }, []);
 
        const onRemoveRestream = React.useCallback(async (episode, channel) => {
                                } : episode
                        ));
                        toastr.success(t('episodes.restreamDialog.removeSuccess'));
-                       setRestreamChannel(null);
-                       setRestreamEpisode(null);
                        setShowRestreamDialog(false);
                } catch (error) {
                        toastr.error(t('episodes.restreamDialog.removeError', { error }));
 
        const onHideRestreamDialog = React.useCallback(() => {
                setShowRestreamDialog(false);
-               setRestreamChannel(null);
-               setRestreamEpisode(null);
        }, []);
 
        const onApplyRestream = React.useCallback((episode, as) => {
                        toastr.error(t('episodes.applyDialog.applyError'));
                        throw e;
                }
-               setRestreamEpisode(null);
                setShowApplyDialog(false);
        }, []);
 
        const onHideApplyDialog = React.useCallback(() => {
                setShowApplyDialog(false);
-               setRestreamEpisode(null);
        }, []);
 
        const value = React.useMemo(() => ({