Yet another simple Tic-tac-toe game on Rust programming lang

extern crate rand;

use std::io;
use std::io::prelude::*;
use std::fmt::{self, Formatter, Display};

#[derive(Debug, Clone, Copy, PartialEq)]
enum Values {
    X,
    Y,
    O
}

impl Display for Values {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        write!(f, "{}", self)
    }
}

#[derive(Debug)]
struct Cell {
    x: i8,
    y: i8,
    value: Values
}

#[derive(Debug)]
struct Row(Cell, Cell, Cell);

#[derive(Debug)]
struct Map(Row, Row, Row);

impl Display for Map {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        write!(f, "1 {:?}[1]    {:?}[2] {:?}[3]\n\
                   2 {:?}[1]    {:?}[2] {:?}[3]\n\
                   3 {:?}[1]    {:?}[2] {:?}[3]",
        &((self.0).0).value, &((self.0).1).value, &((self.0).2).value,
        &((self.1).0).value, &((self.1).1).value, &((self.1).2).value,
        &((self.2).0).value, &((self.2).1).value, &((self.2).2).value
        )
    }
}

fn do_step(game_map: &mut Map, input: &str, who: Values) -> bool {
    let x: i8 = match input.chars().nth(0).unwrap() {
        '1' => 1i8,
        '2' => 2i8,
        '3' => 3i8,
        _   => 0i8
    };
    if x == 0 {return false};
    let y: i8 = match input.chars().nth(2).unwrap() {
        '1' => 1i8,
        '2' => 2i8,
        '3' => 3i8,
        _   => 0i8
    };
    if y == 0 {return false};
    let row = &mut game_map.0;
    let mut cell = &mut row.0;
    if x == cell.x && y == cell.y && cell.value == Values::O {
        cell.value = who;
        return true;
    };
    let mut cell = &mut row.1;
    if x == cell.x && y == cell.y && cell.value == Values::O {
        cell.value = who;
        return true;
    };
    let mut cell = &mut row.2;
    if x == cell.x && y == cell.y && cell.value == Values::O {
        cell.value = who;
        return true;
    };
    let row = &mut game_map.1;
    let mut cell = &mut row.0;
    if x == cell.x && y == cell.y && cell.value == Values::O {
        cell.value = who;
        return true;
    };
    let mut cell = &mut row.1;
    if x == cell.x && y == cell.y && cell.value == Values::O {
        cell.value = who;
        return true;
    };
    let mut cell = &mut row.2;
    if x == cell.x && y == cell.y && cell.value == Values::O {
        cell.value = who;
        return true;
    };
    let row = &mut game_map.2;
    let mut cell = &mut row.0;
    if x == cell.x && y == cell.y && cell.value == Values::O {
        cell.value = who;
        return true;
    };
    let mut cell = &mut row.1;
    if x == cell.x && y == cell.y && cell.value == Values::O {
        cell.value = who;
        return true;
    };
    let mut cell = &mut row.2;
    if x == cell.x && y == cell.y && cell.value == Values::O {
        cell.value = who;
        return true;
    };
    false
}

fn anyone_wins(game_map: &Map) -> Values {
    let row1 = &game_map.0;
    let row2 = &game_map.1;
    let row3 = &game_map.2;
    if (row1.0).value == (row1.1).value && (row1.0).value == (row1.2).value {
        return (row1.0).value;
    } else if (row2.0).value == (row2.1).value && (row2.0).value == (row2.2).value {
        return (row2.0).value;
    } else if (row3.0).value == (row3.1).value && (row3.0).value == (row3.2).value {
        return (row3.0).value;
    } else if (row1.0).value == (row2.0).value && (row1.0).value == (row3.0).value {
        return (row1.0).value;
    } else if (row1.1).value == (row2.1).value && (row1.1).value == (row3.1).value {
        return (row1.1).value;
    } else if (row1.2).value == (row2.2).value && (row1.2).value == (row3.2).value {
        return (row1.2).value;
    } else if (row1.0).value == (row2.1).value && (row1.0).value == (row3.2).value {
        return (row1.0).value;
    } else if (row1.2).value == (row2.1).value && (row1.2).value == (row3.0).value {
        return (row1.2).value;
    };
    Values::O
}

fn main() {
    use Values::{X, Y, O};
    let mut winner = O;
    let mut game_map = Map(
        Row(
            Cell {x: 1, y: 1, value: O},
            Cell {x: 2, y: 1, value: O},
            Cell {x: 3, y: 1, value: O}
        ),
        Row(
            Cell {x: 1, y: 2, value: O},
            Cell {x: 2, y: 2, value: O},
            Cell {x: 3, y: 2, value: O}
        ),
        Row(
            Cell {x: 1, y: 3, value: O},
            Cell {x: 2, y: 3, value: O},
            Cell {x: 3, y: 3, value: O}
        )
    );
    let mut rng = rand::thread_rng();
    let mut counter = 0;
    io::stdout().write(("Hi! You play for `X`.".to_owned() + "\n").as_bytes()).unwrap();
    loop {
        println!("{}", game_map);
        io::stdout().write("Input your move as `x y`, e.g. `1 1` where x = 1 and y = 1 (x: 1, 2, 3; y: 1, 2, 3):\n".as_bytes()).unwrap();
        let mut input = "".to_owned();
        io::stdin().read_line(&mut input)
                   .expect("Failed to read line");
        let step = do_step(&mut game_map, &input.trim(), X);
        if !step {
            let msg = "Invalid input: ".to_owned();
            io::stdout().write((msg + &input.trim() + "\n").as_bytes()).unwrap();
            continue;
        };

        counter += 1;
        if counter == 5 {
            break;
        }

        loop {
            let mut opp_input = "".to_owned();
            #[allow(unused_variables)]
            for i in 1..3 {
                let sample = rand::sample(&mut rng, 1..4, 1)[0];
                let s = match sample {
                    1 => "1",
                    2 => "2",
                    3 => "3",
                    _ => ""
                };
                opp_input.push_str(s);
                opp_input.push_str(" ");
            }
            let step = do_step(&mut game_map, &opp_input.trim(), Y);
            if step {
                break;
            } else {
                let msg = "Invalid input from opponent: ".to_owned();
                io::stdout().write((msg + &opp_input.trim() + "\n").as_bytes()).unwrap();
            };
        }
        if counter > 2 {
            winner = anyone_wins(&game_map);
            if winner != O {break};
        }
    }
    println!("{}", game_map);
    println!("{:?}", "Game over!");
    println!("{:?} win.", winner);
}